minimaz-cli 0.1.0 → 0.1.2

package/src/commands/build.ts

@@ -1,176 +0,0 @@
-import fs from 'fs-extra'
-import path from 'path'
-import CleanCSS from 'clean-css'
-import { minify as minifyHtml } from 'html-minifier-terser'
-import { minify as minifyJs, MinifyOutput } from 'terser'
-
-import { loadConfig } from '../utils/loadConfig.js'
-import { log } from '../utils/logService.js'
-import { applyReplacements, getFile } from '../utils/functions.js'
-
-/**
- * Build the project according to configuration.
- */
-export async function build(): Promise<void> {
-  try {
-    const config: any = await loadConfig()
-    const distDir: string = path.resolve(process.cwd(), config.dist || 'dist')
-
-    // Remove previous dist folder and recreate it
-    await fs.remove(distDir)
-    await fs.ensureDir(distDir)
-
-    /**
-     * Process a single folder
-     * @param srcPathRel Relative path of the source folder
-     * @param destName Destination folder name inside dist
-     */
-    async function processFolder(srcPathRel: string, destName: any): Promise<void> {
-      const fullSrc: string = path.resolve(process.cwd(), srcPathRel)
-      const fullDest: string = path.join(distDir, destName)
-
-      if (!(await fs.pathExists(fullSrc))) {
-        log('warn', `Folder not found: ${srcPathRel}`)
-        return
-      }
-
-      const cssChunks: string[] = []
-      const jsChunks: string[] = []
-
-      // Recursive walk function to process files
-      async function walk(src: string, dest: string): Promise<void> {
-        await fs.ensureDir(dest)
-
-        for (const item of await fs.readdir(src)) {
-          const srcPath: string = path.join(src, item)
-          const destPath: string = path.join(dest, item)
-          const stat: fs.Stats = await fs.stat(srcPath)
-          const ext: string = path.extname(item).toLowerCase()
-
-          if (stat.isDirectory()) {
-            await walk(srcPath, destPath)
-            continue
-          }
-
-          try {
-            switch (ext) {
-              case '.html': {
-                let content: string = await getFile(srcPath, config.replace)
-                if (config.minify?.html) {
-                  content = await minifyHtml(content, {
-                    collapseWhitespace: true,
-                    removeComments: true,
-                    minifyJS: config.minify?.ts,
-                    minifyCSS: config.minify?.css
-                  })
-                }
-                await fs.outputFile(destPath, content)
-                break
-              }
-
-              case '.css': {
-                const content: string = await getFile(srcPath, config.replace)
-                cssChunks.push(content)
-                break
-              }
-
-              case '.js': {
-                const content: string = await getFile(srcPath, config.replace)
-                jsChunks.push(content)
-                break
-              }
-              /*
-              case '.ts': {
-                const result = await esbuild.build({
-                  entryPoints: [srcPath],
-                  bundle: false,
-                  minify: !!config.minify?.ts,
-                  platform: 'browser',
-                  format: 'esm',
-                  write: false
-                })
-                let compiled = result.outputFiles[0].text
-                compiled = applyReplacements(compiled, config.replace)
-                if (srcPathRel === config.src) jsChunks.push(compiled)
-                break
-              }
-              */
-              default:
-                await fs.copy(srcPath, destPath)
-                break
-            }
-          } catch (error: any) {
-            log('error', `Failed to process file: ${srcPath} - ${error.message}`)
-          }
-        }
-      }
-
-      await walk(fullSrc, fullDest)
-
-      // Merge CSS/JS only for the root source folder
-      if (srcPathRel === config.src) {
-        try {
-          if (config.styles?.length) {
-            for (const style of config.styles) {
-              const fullPath: string = path.resolve(process.cwd(), style)
-              if (await fs.pathExists(fullPath)) {
-                let css: string = await fs.readFile(fullPath, 'utf-8')
-                css = applyReplacements(css, config.replace)
-                cssChunks.push(css)
-              } else {
-                log('warn', `Style file not found: ${style}`)
-              }
-            }
-          }
-
-          if (config.scripts?.length) {
-            for (const script of config.scripts) {
-              const fullPath: string = path.resolve(process.cwd(), script)
-              if (await fs.pathExists(fullPath)) {
-                let js: string = await fs.readFile(fullPath, 'utf-8')
-                js = applyReplacements(js, config.replace)
-                jsChunks.push(js)
-              } else {
-                log('warn', `Script file not found: ${script}`)
-              }
-            }
-          }
-
-          // Write final CSS bundle
-          if (cssChunks.length > 0) {
-            let finalCss: string = cssChunks.join('')
-            if (config.minify?.css) finalCss = new CleanCSS().minify(finalCss).styles
-            await fs.outputFile(path.join(distDir, 'style.css'), finalCss)
-          }
-
-          // Write final JS bundle
-          if (jsChunks.length > 0) {
-            let finalJs: string = jsChunks.join('')
-            if (config.minify?.js) {
-              const minified: MinifyOutput = await minifyJs(finalJs)
-              finalJs = minified.code ?? ''
-            }
-            if (finalJs) await fs.outputFile(path.join(distDir, 'script.js'), finalJs)
-          }
-        } catch (error: any) {
-          log('error', `Failed to merge CSS/JS: ${error.message}`)
-        }
-      }
-
-      log('success', `Processed folder: ${srcPathRel} -> /${destName}`)
-    }
-
-    // Process all folders defined in configuration
-    if (config.folders && Object.keys(config.folders).length > 0) {
-      for (const [srcPathRel, destName] of Object.entries(config.folders)) {
-        await processFolder(srcPathRel, destName)
-      }
-    } else {
-      log('warn', 'No folders defined in config. Nothing to build.')
-    }
-
-    log('success', `Build completed. Output saved in /${config.dist}`)
-  } catch (error: any) {
-    log('error', `Build failed: ${error.message}`)
-  }
-}

package/src/commands/help.ts

@@ -1,33 +0,0 @@
-/**
- * Displays CLI usage information for Minimaz.
- * Lists all available commands and their options.
- *
- * Example:
- *   minimaz init my-site -t default
- *   minimaz build
- *   minimaz template --list
- */
-export function help(): void {
-  console.log([
-    'Usage:',
-    '',
-    '\tminimaz init | i <project-name>',
-    '\t\tCreate a new project (default: "minimaz-site")',
-    '\t\tOptions:',
-    '\t\t\t--template | -t <template-name>\tUse a global template (default: "default")',
-    '',
-    '\tminimaz build | b',
-    '\t\tBuild and minify files into the dist folder',
-    '',
-    '\tminimaz template | t [path]',
-    '\t\tSave current folder as a template (no path = current folder)',
-    '\t\tOptions:',
-    '\t\t\t--list | -l\tList available global templates',
-    '\t\t\t--delete | -d <template-name>\tDelete a global template',
-    '',
-    '\tminimaz help | h',
-    '\t\tShow this help message'
-  ].join('\n'));
-}
-
-// @TODO add help for each command

package/src/commands/init.ts

@@ -1,56 +0,0 @@
-import fs from 'fs-extra'
-import path from 'path'
-import os from 'os'
-import { log } from '../utils/logService.js'
-import { createGlobalDir } from '../utils/functions.js'
-
-/**
- * Initializes a new Minimaz project by copying a predefined template
- * from the user's global Minimaz directory (~/.minimaz/templates).
- *
- * @param projectName - The name of the project folder to create.
- * @param options - Optional settings (e.g. { template: 'landing' }).
- *
- * Process:
- * 1. Ensures the global `.minimaz` directory exists.
- * 2. Locates the chosen template inside `.minimaz/templates`.
- * 3. Copies the template files to the new project folder.
- * 4. Adds `.gitignore` if available.
- * 5. Logs actions and errors.
- */
-export async function init(projectName: string, options: any = {}): Promise<void> {
-  const minimazDir: string = path.join(os.homedir(), '.minimaz')
-
-  // Step 1: Create global folder if missing
-  if (!await fs.pathExists(minimazDir)) {
-    log('info', `Global folder '${minimazDir}' not found. Creating...`)
-    await createGlobalDir()
-  }
-
-  // Step 2: Determine paths
-  const templateDir: string = path.join(minimazDir, 'templates', options.template || 'default')
-  const targetDir: string = path.resolve(process.cwd(), projectName)
-
-  // Step 3: Validate template existence
-  if (!await fs.pathExists(templateDir))
-    throw new Error(`Template '${options.template}' not found.`)
-
-  try {
-    // Step 4: Copy template files to target directory
-    await fs.copy(templateDir, targetDir)
-
-    // Step 5: Copy .gitignore if available at the parent level
-    const gitignoreSrc: string = path.join(templateDir, '..', 'gitignore')
-    const gitignoreDest: string = path.join(targetDir, '.gitignore')
-    if (await fs.pathExists(gitignoreSrc)) {
-      await fs.copy(gitignoreSrc, gitignoreDest)
-      log('info', `.gitignore added to project.`)
-    }
-
-    // Step 6: Confirm success
-    log('success', `Project '${projectName}' created using template '${options.template}'.`)
-  } catch (error: any) {
-    // Step 7: Handle any failure during copy
-    throw new Error(`Failed to create project: ${error.message}`)
-  }
-}

package/src/commands/template.ts

@@ -1,146 +0,0 @@
-import fs from 'fs-extra'
-import os from 'os'
-import path from 'path'
-import { log } from '../utils/logService.js'
-import { askQuestion, listTemplates, getGlobalNodeModulesPath } from '../utils/functions.js'
-
-/**
- * Handles all template-related operations:
- * - Save current folder as a global template
- * - Update existing templates
- * - Delete templates
- * - Sync templates from node_modules
- *
- * @param targetPath - Optional path of the folder to save as template
- * @param options - CLI flags (--list, --delete, --update, etc.)
- */
-export async function template(targetPath?: string, options: any = {}): Promise<void> {
-  const templatesDir: string = path.join(os.homedir(), '.minimaz', 'templates')
-  const deleteName: string | undefined = options.delete || options.d
-  const updateName: string | undefined = options.update || options.u
-
-  if (deleteName) return await deleteTemplate(templatesDir, deleteName)
-  if (options.list || options.l) return await listTemplates(templatesDir)
-
-  // --- UPDATE MODE ---
-  if (updateName !== undefined) {
-    if (typeof updateName === 'string' && updateName.trim()) {
-      return await updateSingleTemplate(templatesDir, updateName.trim())
-    } else {
-      return await updateFromNodeModules(templatesDir)
-    }
-  }
-
-  // Default action: save current folder as a template
-  await saveTemplate(templatesDir, targetPath)
-}
-
-/**
- * Updates a single template with files from the current working directory.
- *
- * @param templatesDir - Global templates directory (~/.minimaz/templates)
- * @param templateName - Name of the template to update
- */
-async function updateSingleTemplate(templatesDir: string, templateName: string): Promise<void> {
-  const sourceDir: string = path.resolve(process.cwd())
-  const targetDir: string = path.join(templatesDir, templateName)
-
-  if (!await fs.pathExists(targetDir))
-    throw new Error(`Template '${templateName}' not found in ~/.minimaz/templates`)
-
-  const answer: string = await askQuestion(`❓ Update template '${templateName}' with current directory? (Y/N) `)
-  if (answer !== 'y' && answer !== '') {
-    log('info', 'Update cancelled.')
-    return
-  }
-
-  try {
-    await fs.copy(sourceDir, targetDir, { overwrite: true })
-    log('success', `Template '${templateName}' updated from current directory.`)
-  } catch (error: any) {
-    throw new Error(`Failed to update '${templateName}': ${error.message}`)
-  }
-}
-
-/**
- * Updates all templates from the global node_modules/minimaz/src/templates folder.
- * This ensures the local templates are synced with the installed package.
- *
- * @param templatesDir - Global templates directory (~/.minimaz/templates)
- */
-async function updateFromNodeModules(templatesDir: string): Promise<void> {
-  const nodeModulesPath: string = path.join(getGlobalNodeModulesPath(), 'src', 'templates')
-
-  if (!await fs.pathExists(nodeModulesPath)) throw new Error(`'node_modules/minimaz/src/templates' not found.`)
-
-  const items: string[] = await fs.readdir(nodeModulesPath)
-
-  const answer: string = await askQuestion(`⚠️ Update local templates overwriting them with defaults? (Y/N): `)
-  if (answer !== 'y' && answer !== '') {
-    log('info', 'Update cancelled.')
-    return
-  }
-
-  try {
-    for (const item of items) {
-      const src: string = path.join(nodeModulesPath, item)
-      const dest: string = path.join(templatesDir, item)
-      await fs.copy(src, dest, { overwrite: true })
-      log('success', `Updated '${item}'`)
-    }
-    log('info', `✨ All templates and files updated successfully.`)
-  } catch (error: any) {
-    throw new Error(`Update failed: ${error.message}`)
-  }
-}
-
-/**
- * Deletes a global template by name from ~/.minimaz/templates.
- *
- * @param dir - Global templates directory
- * @param name - Template name to delete
- */
-async function deleteTemplate(dir: string, name: string): Promise<void> {
-  if (!name) throw new Error('No template name specified to delete.')
-  const target: string = path.join(dir, name)
-  if (!await fs.pathExists(target)) throw new Error(`Template not found: ${name}`)
-
-  const confirm = await askQuestion(`❓ Confirm delete '${name}'? (Y/N) `)
-  if (confirm.toLowerCase() !== 'y') {
-    log('info', 'Delete cancelled.')
-    return
-  }
-
-  try {
-    await fs.remove(target)
-    log('success', `Template '${name}' deleted.`)
-  } catch (error: any) {
-    throw new Error(`Delete error: ${error.message}`)
-  }
-}
-
-/**
- * Saves a folder (current or specified) as a new global template.
- *
- * @param dir - Global templates directory (~/.minimaz/templates)
- * @param targetPath - Optional path to save as a template
- */
-async function saveTemplate(dir: string, targetPath?: string): Promise<void> {
-  let source: string = targetPath ? path.resolve(process.cwd(), targetPath) : process.cwd()
-
-  if (!await fs.pathExists(source)) {
-    log('warn', `Path not found: ${source}`)
-    const answer: string = (await askQuestion('❓ Use current directory instead? (Y/N):\t')).trim().toLowerCase()
-    if (answer !== 'y' && answer !== '') throw new Error('Operation cancelled.')
-    source = process.cwd()
-  }
-
-  try {
-    await fs.ensureDir(dir)
-    const dest: string = path.join(dir, path.basename(source))
-    await fs.copy(source, dest)
-    log('success', `Template saved to ${dest}`)
-  } catch (error: any) {
-    throw new Error(`Failed to save template: ${error.message}`)
-  }
-}

package/src/utils/functions.ts

@@ -1,161 +0,0 @@
-import readline from 'readline'
-import fs from 'fs-extra'
-import path from 'path'
-import os from 'os'
-import { log } from './logService.js'
-import { execSync } from 'child_process'
-
-// ----- Types -----
-interface Args {
-  _: string[]
-  [key: string]: string | boolean | string[]
-}
-
-// ----- Parse CLI Arguments -----
-// Converts raw process arguments into structured key-value pairs
-export function parseArgs(rawArgs: string[]): Args {
-  const args: Args = { _: [] }
-  for (let i = 0; i < rawArgs.length; i++) {
-    const arg: string = rawArgs[i]
-    if (arg.startsWith('-')) {
-      const key: string = arg.startsWith('--') ? arg.slice(2) : arg.slice(1)
-      const next: string = rawArgs[i + 1]
-      const hasValue: boolean = !!next && !next.startsWith('-')
-      args[key] = hasValue ? next : true
-      if (hasValue) i++
-    } else {
-      args._.push(arg)
-    }
-  }
-  return args
-}
-
-// ----- Ask Question from CLI -----
-// Prompts the user with a question and returns the input
-export function askQuestion(query: string): Promise<string> {
-  return new Promise(resolve => {
-    const rl: readline.Interface = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout
-    })
-    rl.question(query, answer => {
-      rl.close()
-      resolve(answer.trim())
-    })
-  })
-}
-
-// ----- List Templates -----
-// Displays all available global templates in the given directory
-export async function listTemplates(dir: string): Promise<void> {
-  if (!await fs.pathExists(dir)) {
-    log('info', 'No templates directory found.')
-    return
-  }
-
-  const templates: string[] = await fs.readdir(dir)
-  if (templates.length === 0) log('info', 'No global templates available.')
-  else {
-    log('info', 'Available global templates:')
-    templates.forEach(t => log('info', `- ${t}`))
-  }
-}
-
-// ----- Apply Replacements -----
-// Replaces all occurrences of keys in content with their corresponding values
-export function applyReplacements(content: string, replacements: Record<string, string> = {}): string {
-  for (const [from, to] of Object.entries(replacements)) {
-    content = content.split(from).join(to)
-  }
-  return content
-}
-
-// ----- Read File with Replacements -----
-// Reads a file and applies string replacements if provided
-export async function getFile(srcPath: string, replace?: Record<string, string>): Promise<string> {
-  try {
-    let file: string = await fs.readFile(srcPath, 'utf-8')
-    if (replace) file = applyReplacements(file, replace)
-    return file
-  } catch (error: any) {
-    log('error', `Failed to read file ${srcPath}: ${error.message}`)
-    return ''
-  }
-}
-
-// ----- Global Node Modules Path -----
-// Returns the path to global node_modules depending on the platform
-
-export function getGlobalNodeModulesPath(): string {
-  try {
-    const prefix = execSync('npm config get prefix', { encoding: 'utf-8' }).trim();
-    if (!prefix) throw new Error('Empty prefix');
-    return process.platform === 'win32'
-      ? path.join(prefix, 'node_modules', 'minimaz-cli')
-      : path.join(prefix, 'lib', 'node_modules', 'minimaz-cli');
-  } catch {
-    // fallback
-    return process.platform === 'win32'
-      ? path.join(process.env.APPDATA || '', 'npm', 'node_modules', 'minimaz-cli')
-      : '/usr/local/lib/node_modules/minimaz-cli';
-  }
-}
-
-
-// ----- Create Global Templates Folder -----
-// Creates ~/.minimaz/templates and copies default templates if folder is empty
-export async function createGlobalDir(): Promise<void> {
-  const minimazDir = path.join(os.homedir(), '.minimaz')
-  const globalTemplatesDir = path.join(minimazDir, 'templates')
-  const defaultTemplatesDir = path.join(getGlobalNodeModulesPath(), 'src', 'templates')
-  const settingsPath = path.join(minimazDir, 'settings.json')
-
-  console.log(defaultTemplatesDir)
-
-  // ----- Ensure node_modules path exists (fallback for portable setups) -----
-
-  try {
-    // ----- Ensure minimaz dir exists -----
-    await fs.ensureDir(minimazDir)
-
-    // ----- Create settings.json if missing -----
-    if (!await fs.pathExists(settingsPath)) {
-      const defaultSettings = {
-        createdAt: new Date().toISOString(),
-        templatesPath: globalTemplatesDir,
-        npmGlobalPath: getGlobalNodeModulesPath()
-      }
-      await fs.outputJson(settingsPath, defaultSettings, { spaces: 2 })
-      log('success', `Created settings.json at ${settingsPath}`)
-    }
-
-    // ----- Check if templates folder exists -----
-    const exists = await fs.pathExists(globalTemplatesDir)
-    const isEmpty = exists ? (await fs.readdir(globalTemplatesDir)).length === 0 : true
-
-    if (!exists) {
-      await fs.ensureDir(globalTemplatesDir)
-      log('success', 'Created global templates directory.')
-    }
-
-    // ----- Skip copy if not empty -----
-    if (!isEmpty) {
-      log('info', 'Global templates directory not empty. Skipping copy.')
-      return
-    }
-
-    const templates: string[] = await fs.readdir(defaultTemplatesDir)
-
-    console.log(templates)
-    // ----- Copy default templates -----
-    for (const name of await fs.readdir(defaultTemplatesDir)) {
-      await fs.copy(path.join(defaultTemplatesDir, name), path.join(globalTemplatesDir, name))
-      log('success', `Copied template '${name}'.`)
-    }
-
-    log('success', 'Default templates setup completed.')
-  } catch (error: any) {
-    log('error', `Failed to create global templates directory: ${error.message}`)
-    throw error
-  }
-}

package/src/utils/loadConfig.ts

@@ -1,61 +0,0 @@
-import fs from 'fs-extra'
-import path from 'path'
-import { log } from './logService.js'
-
-// ----- Default Config -----
-// Provides default values for project build and minification
-const defaultConfig: any = {
-  src: 'src',
-  dist: 'dist',
-  public: 'public',
-  minify: {
-    html: true,
-    css: true,
-    js: true
-  },
-  replace: {}
-}
-
-// ----- Deep Merge Function -----
-// Recursively merges user config into default config
-function deepMerge(target: any, source: any): any {
-  const result: any = { ...target }
-
-  for (const key in source) {
-    if (
-      source[key] &&
-      typeof source[key] === 'object' &&
-      !Array.isArray(source[key])
-    ) {
-      result[key] = deepMerge(target[key] || {}, source[key])
-    } else if (source[key] !== undefined) {
-      result[key] = source[key]
-    }
-  }
-
-  return result
-}
-
-// ----- Load User Config -----
-// Loads minimaz.config.tson if present and merges it with default config
-export async function loadConfig(): Promise<any> {
-  const configPath: string = path.resolve(process.cwd(), 'minimaz.config.json')
-
-  let userConfig: Partial<any> = {}
-  if (await fs.pathExists(configPath)) {
-    try {
-      userConfig = await fs.readJson(configPath)
-      log('info', 'Loaded config from minimaz.config.tson')
-    } catch (error: any) {
-      throw new Error(`Failed to parse minimaz.config.tson: ${error.message}`)
-    }
-  } else {
-    log('info', 'No minimaz.config.tson found. Using default config')
-  }
-
-  const config: any = deepMerge(defaultConfig, userConfig)
-
-  if (!config.src || !config.dist) throw new Error('Invalid configuration: src and dist are required')
-
-  return config
-}

package/src/utils/logService.ts

@@ -1,19 +0,0 @@
-// ----- Log Types -----
-type LogType = 'error' | 'warn' | 'success' | 'info' | 'log'
-
-// ----- Log Function -----
-// Prints a message to console with icon based on type
-export function log(type: LogType = 'log', message: string): void {
-  const icons: Record<LogType, string> = {
-    error: '❌',
-    warn: '⚠️',
-    success: '✅',
-    info: 'ℹ️',
-    log: '📁' // default icon
-  }
-
-  // Use console.error/console.warn only for error and warn
-  if (type === 'error') console.error(icons[type], message)
-  else if (type === 'warn') console.warn(icons[type], message)
-  else console.log(icons[type] || icons.log, message)
-}

package/src/utils/postInstall.ts

@@ -1,16 +0,0 @@
-import { createGlobalDir } from './functions.js'
-import { log } from './logService.js'
-
-// ----- Setup Default Templates -----
-// Runs after install to ensure global templates exist
-async function setupDefaultTemplates(): Promise<void> {
-  try {
-    await createGlobalDir()
-    log('success', 'Postinstall: Global templates setup completed.')
-  } catch (error: any) {
-    log('error', `Postinstall setup failed: ${error.message}`)
-  }
-}
-
-// Execute setup
-setupDefaultTemplates()