minimaz-cli 0.1.0 → 0.1.1

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/templates/default/minimaz.config.json

@@ -1,26 +0,0 @@
-{
-    "src": "src",
-    "dist": "dist",
-    "public": "public",
-    "minify": {
-        "html": true,
-        "css": true,
-        "js": true,
-        "ts": true
-    },
-    "replace": {
-        "../public/": "public/"
-    },
-    "styles": [
-        "style.css",
-        "style-2.css"
-    ],
-    "scripts": [
-        "script.js",
-        "script-2.js"
-    ],
-    "folders": {
-        "src": "",
-        "public": "public"
-    }
-}

package/src/templates/default/src/index.html

@@ -1,80 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>Welcome to Minimaz</title>
-  <link rel="stylesheet" href="style.css" />
-  <link rel="icon" href="../public/favicon.ico" type="image/x-icon" />
-</head>
-<body>
-  <header>
-    <nav>
-      <a class="btn active" href="#">Home</a>
-      <a class="btn" href="pages/about.html">About</a>
-      <a class="btn" href="https://github.com/zeller-dev/minimaz" target="_blank">GitHub</a>
-    </nav>
-  </header>
-
-  <main class="container">
-    <h1>🚀 Welcome to Minimaz</h1>
-    <p><strong>Minimaz</strong> is a minimal static site builder designed for speed and simplicity. It helps you:</p>
-    <ul>
-      <li>💡 Organize your files with a simple structure</li>
-      <li>⚙️ Automatically build and minify HTML, CSS, JS, and TS</li>
-      <li>🔄 Customize file inclusion order using <code>minimaz.config.json</code></li>
-    </ul>
-
-    <h2>🔧 Getting Started</h2>
-    <p>Install and use Minimaz with the following commands:</p>
-    <pre><code># 🔨 Initialize a new project
-npx minimaz init my-site
-
-# 🏗️ Build the site
-npx minimaz build
-
-# 📦 Save template or list/delete existing ones
-npx minimaz template &lt;path&gt; [--list|-l] [--delete|-d]
-
-# 💬 Show help guide
-npx minimaz help</code></pre>
-
-    <h2>📁 Project Structure</h2>
-    <pre><code>my-site/
-├── src/                  # Source files (HTML, CSS, JS, TS)
-├── public/               # Static assets (images, fonts, etc.)
-├── dist/                 # Output directory (auto-generated)
-└── minimaz.config.json   # Configuration file</code></pre>
-
-    <h2>⚙️ Configuration</h2>
-    <pre><code>{
-  "src": "src",
-  "dist": "dist",
-  "public": "public",
-  "minify": { "html": true, "css": true, "js": true, "ts": true },
-  "replace": { "../public/": "public/" },
-  "styles": [ "reset.css", "style.css", "theme.css" ],
-  "scripts": [ "libs/jquery.js", "utils.js", "script.js" ]
-}</code></pre>
-
-    <h2>📤 Production</h2>
-    <p>The final output will be generated in the <code>dist/</code> folder, ready for deployment.</p>
-
-    <h2>❓ Available Commands</h2>
-    <ul>
-      <li><code>init</code> / <code>i</code> – Initialize a new project</li>
-      <li><code>build</code> / <code>b</code> – Build and minify the project</li>
-      <li><code>help</code> / <code>h</code> – Show the help message</li>
-      <li><code>template</code> / <code>t</code> – Manage templates (with <code>--list</code> and <code>--delete</code> options)</li>
-    </ul>
-
-    <p>You're ready to build fast and clean static websites. Happy coding! 🛠️</p>
-  </main>
-
-  <footer>
-    <p>&copy; 2025 Minimaz. All rights reserved.</p>
-  </footer>
-
-  <script src="script.js"></script>
-</body>
-</html>

package/src/templates/default/src/pages/about.html

@@ -1,46 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-
-<head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Welcome to Minimaz</title>
-    <link rel="stylesheet" href="../style.css" />
-    <link rel="shortcut icon" href="../../public/favicon.ico" type="image/x-icon">
-
-</head>
-
-<body>
-    <header>
-        <nav>
-            <a class='btn' href="../index.html">Home</a>
-            <a class='btn active' href="pages/about.html">About</a>
-            <a class='btn' target="_blank" href="https://github.com/zeller-dev/minimaz">GitHub</a>
-        </nav>
-    </header>
-    <div class="container">
-        <h1>About Minimaz</h1>
-        <p><strong>Minimaz</strong> is a minimal build tool that helps you quickly scaffold and minify HTML, CSS, and
-            JavaScript projects.</p>
-
-        <h2>Features</h2>
-        <ul>
-            <li>Zero-config HTML/CSS/JS minification</li>
-            <li>Folder structure based on <code>src</code>, <code>public</code>, and <code>dist</code></li>
-            <li>Simple CLI with <code>init</code>, <code>build</code>, and <code>help</code> commands</li>
-        </ul>
-
-        <h2>Getting Started</h2>
-        <pre><code>$ minimaz init my-project
-$ cd my-project
-$ minimaz build</code></pre>
-
-        <p>Learn more or contribute on <a href="#">GitHub</a>.</p>
-    </div>
-    <footer>
-        <p>&copy; 2023 Minimaz. All rights reserved.</p>
-    </footer>
-    <script src="../script.js"></script>
-</body>
-
-</html>

package/src/templates/default/src/script.js

@@ -1 +0,0 @@
-console.log('Minimaz is ready!')

package/src/templates/default/src/style.css

@@ -1,99 +0,0 @@
-:root {
-  --primary-color: #338ca8;
-  --background-color: #222;
-  --foreground-color: #f5f5f5;
-  --code-bg: #333;
-  --code-text: #eeeeff;
-  font-size: 16px;
-}
-
-* {
-  box-sizing: border-box;
-}
-
-header,
-footer {
-  background-color: var(--code-bg);
-  padding:1rem;
-}
-
-body {
-  font-family: 'Segoe UI', sans-serif;
-  margin: 0;
-  background: var(--background-color);
-  color: var(--foreground-color);
-  line-height: 1.6;
-}
-
-.container {
-  max-width: 800px;
-  margin: auto;
-  padding: 1rem;
-}
-
-h1,
-h2,
-h3 {
-  color: var(--primary-color);
-  margin-top: 2rem;
-}
-
-p {
-  margin: 1rem 0;
-}
-
-code {
-  background: var(--code-bg);
-  color: var(--code-text);
-  padding: 0.2rem 0.4rem;
-  border-radius: 4px;
-  font-family: monospace;
-}
-
-pre {
-  background: var(--code-bg);
-  color: #ddd;
-  padding: 1rem;
-  overflow-x: auto;
-  border-radius: 6px;
-  font-family: monospace;
-  border-left: 4px solid var(--primary-color);
-}
-
-a {
-  color: var(--primary-color);
-  text-decoration: none;
-}
-
-.btn {
-  transition: all 0.15s ease-in-out;
-  background-color: var(--primary-color);
-  border: none;
-  color: #fff;
-  padding: 10px 20px;
-  font-size: 1rem;
-  margin: .5rem .2rem;
-  cursor: pointer;
-  border-radius: 5px;
-  display: inline-block;
-  text-align: center;
-}
-
-.btn:hover {
-  opacity: 0.85;
-}
-
-.btn.active {
-  background-color: var(--code-bg);
-  color: #fff;
-  pointer-events: none;
-}
-
-header {
-  font-weight: 600;
-}
-
-footer p {
-  text-align: center;
-  margin: 0;
-}

package/src/templates/gitignore

@@ -1,2 +0,0 @@
-dist
-.vscode