create-marp-presentation 1.1.0 → 1.2.1

package/README.md

@@ -1,64 +1,72 @@
 # Create Marp Presentation
 
-Create a new Marp presentation with a single command.
+Create beautiful presentations in Markdown. Zero setup.
 
-## Installation
+## Quick Start
 
 ```bash
 npx create-marp-presentation my-presentation
+cd my-presentation
+npm run dev
 ```
 
-## Usage
+That's it! Edit `presentation.md` and see changes live at `http://localhost:8080`.
 
-```bash
-cd my-presentation
-npm run dev     # Live preview
-npm run build:all  # Build all formats
-```
+## VSCode Setup
 
-## Features
+For the best editing experience, install [Marp for VSCode](https://marketplace.visualstudio.com/items?itemName=marp-team.marp-vscode):
 
-- 🚀 One-command setup
-- 📝 Markdown slides
-- 🎨 Marp themes
-- 📦 HTML, PDF, PPTX export
-- 📁 Static files support
-- 🔥 Live preview
+1. Open VSCode
+2. Press `Ctrl+Shift+X` (or `Cmd+Shift+X` on Mac)
+3. Search "Marp for VSCode"
+4. Click Install
 
-## Local Testing
+After installing, open any `.md` file and click the **Marp: Preview** button in the top-right corner.
 
-To test project generation without publishing to npm:
+## What You Get
 
-```bash
-# Clone the repository
-git clone https://github.com/echernyshev/marp-presentation-template.git
-cd marp-presentation-template
+- **Markdown slides** - Write presentations in plain text
+- **Live preview** - See changes instantly in browser
+- **Export anywhere** - HTML, PDF, PPTX with one command
+- **Themes** - Beautiful built-in themes, add more anytime
+- **Static files** - Images and assets copied automatically
 
-# Install dependencies for tests
-npm install
+## Commands
 
-# Run tests
-npm test
+| Command | What it does |
+|---------|--------------|
+| `npm run dev` | Live preview at http://localhost:8080 |
+| `npm run build:all` | Export to HTML, PDF, and PPTX |
+| `npm run clean` | Remove output folder |
 
-# Create a test project (interactive mode)
-node index.js test-project
+## Theme Management
 
-# Check the contents
-cd test-project
-ls -la
-npm run dev
-```
+Add and switch themes anytime.
 
-Other example commands:
+### Quick Theme Commands
 
 ```bash
-# Create a test project without examples
-echo "n" | node index.js test-project-minimal
+npm run theme:add        # Interactive: select themes to add
+npm run theme:add beam   # Add specific themes
+npm run theme:list       # See what's available
+npm run theme:set marpx  # Change active theme
 ```
 
-## Documentation
+When you create a project, you'll be prompted to add themes. Add more later with `npm run theme:add`.
+
+[See full theme documentation →](docs/theme-management.md)
+
+## Local Development
 
-After creating a project, read the README in the project folder.
+To test without publishing to npm:
+
+```bash
+git clone https://github.com/echernyshev/marp-presentation-template.git
+cd marp-presentation-template
+npm install
+npm test
+node index.js test-project
+```
 
 ## License
 

package/cli/commands/add-themes-cli.js

@@ -0,0 +1,85 @@
+// cli/commands/add-themes-cli.js
+/**
+ * Add themes to existing project command for meta-package CLI
+ * This file is NOT copied to generated projects
+ */
+const fs = require('fs');
+const path = require('path');
+
+const { AddThemesCommand } = require('../../lib/add-themes-command');
+const { ThemeError } = require('../../lib/errors');
+
+/**
+ * Add themes to an existing project
+ * @param {string} targetPath - Path to the target project
+ * @param {Object} options - Configuration options
+ * @param {string} options.themesLibraryPath - Path to themes library
+ * @param {string[]} options.themeNames - Specific theme names to add (optional)
+ * @returns {Promise<void>}
+ */
+async function addThemesToExistingProject(targetPath, options = {}) {
+  const {
+    themesLibraryPath = path.join(__dirname, '../..', 'themes'),
+    themeNames = null
+  } = options;
+
+  // Validate target path exists
+  const resolvedPath = path.resolve(targetPath);
+  if (!fs.existsSync(resolvedPath)) {
+    console.error(`Error: Directory does not exist: ${targetPath}`);
+    throw new ThemeError(`Target path does not exist: ${targetPath}`);
+  }
+
+  // Check if it's a valid Marp project (has presentation.md or package.json)
+  const hasPresentation = fs.existsSync(path.join(resolvedPath, 'presentation.md'));
+  const hasPackageJson = fs.existsSync(path.join(resolvedPath, 'package.json'));
+
+  if (!hasPresentation && !hasPackageJson) {
+    console.warn('Warning: This does not appear to be a Marp presentation project.');
+    console.warn('  (no presentation.md or package.json found)');
+  }
+
+  // Create AddThemesCommand with themes library path
+  const command = new AddThemesCommand({
+    templatePath: themesLibraryPath,
+    interactive: true
+  });
+
+  try {
+    console.log(`Adding themes to: ${resolvedPath}`);
+    console.log();
+
+    // Execute command - pass theme names if provided, otherwise prompt
+    const { copied, skipped, conflicts } = await command.execute(resolvedPath, {
+      themes: themeNames || undefined
+    });
+
+    // Show summary
+    const copiedNames = copied.map(t => t.name);
+    console.log(`\nCopied themes: ${copiedNames.join(', ') || 'none'}`);
+    if (skipped.length > 0) {
+      console.log(`Skipped: ${skipped.join(', ')}`);
+    }
+    if (conflicts.length > 0) {
+      console.log(`Conflicts: ${conflicts.join(', ')}`);
+    }
+
+    console.log();
+    console.log('Themes added successfully!');
+    console.log(`\nNext steps in ${targetPath}:`);
+    console.log('  npm run theme:list # List available themes');
+    console.log('  npm run theme:set <theme>  # Set active theme');
+    console.log();
+
+  } catch (error) {
+    if (error instanceof ThemeError) {
+      console.error(`Error: ${error.message}`);
+      throw error;
+    }
+    throw error;
+  }
+}
+
+module.exports = {
+  addThemesToExistingProject
+};

package/cli/commands/create-project.js

@@ -0,0 +1,199 @@
+// cli/commands/create-project.js
+/**
+ * Project creation command for meta-package CLI
+ * This file is NOT copied to generated projects
+ */
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const { AddThemesCommand } = require('../../lib/add-themes-command');
+const { Prompts } = require('../../lib/prompts');
+const { ThemeManager } = require('../../lib/theme-manager');
+
+const { copyDir, copyOptionalFiles } = require('../utils/file-utils');
+const { askCreateExamples } = require('../utils/prompt-utils');
+
+/**
+ * Validate project name
+ * @param {string} name - Project name to validate
+ * @returns {boolean} True if valid
+ */
+function validateProjectName(name) {
+  const validName = /^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]$/;
+  return validName.test(name);
+}
+
+/**
+ * Parse --path argument from argv
+ * @param {string[]} argv - Process argv (should start from index 2)
+ * @returns {{outputPath: string, pathIndex: number|null}} Parsed arguments
+ */
+function parsePathArg(argv) {
+  let outputPath = process.cwd();
+  const pathIndex = argv.indexOf('--path');
+  if (pathIndex !== -1 && pathIndex + 1 < argv.length) {
+    return { outputPath: null, pathIndex }; // Signal that validation is needed
+  }
+  return { outputPath, pathIndex: null };
+}
+
+/**
+ * Create a new Marp presentation project
+ * @param {string} projectName - Name of the project
+ * @param {Object} options - Configuration options
+ * @param {string} options.outputPath - Output directory path (default: current directory)
+ * @param {string} options.templatePath - Path to template directory
+ * @param {string} options.themesLibraryPath - Path to themes library
+ * @param {Function} options.validatePath - Path validation function
+ * @returns {Promise<void>}
+ */
+async function createProject(projectName, options = {}) {
+  const {
+    outputPath: providedOutputPath,
+    templatePath = path.join(__dirname, '../..', 'template'),
+    themesLibraryPath = path.join(__dirname, '../..', 'themes'),
+    validatePath
+  } = options;
+
+  // Validate project name
+  if (!validateProjectName(projectName)) {
+    console.error(`Invalid project name: "${projectName}"`);
+    console.error('Project name must be lowercase, contain only letters, numbers, and hyphens.');
+    throw new Error('Invalid project name');
+  }
+
+  // Determine output path
+  let outputPath = providedOutputPath || process.cwd();
+
+  // Build final project path
+  const projectPath = path.join(outputPath, projectName);
+
+  // Check if project already exists
+  if (fs.existsSync(projectPath)) {
+    console.error(`Directory "${projectName}" already exists.`);
+    throw new Error('Project directory already exists');
+  }
+
+  console.log(`Creating Marp presentation: ${projectName}`);
+  if (outputPath !== process.cwd()) {
+    console.log(`  Location: ${projectPath}`);
+  }
+  console.log();
+
+  // Ask about example slides
+  const createExamples = await askCreateExamples();
+
+  // Create project directory
+  fs.mkdirSync(projectPath, { recursive: true });
+
+  // Copy template completely
+  copyDir(templatePath, projectPath);
+
+  // Copy lib scripts to project
+  const rootLibPath = path.join(__dirname, '../..', 'lib');
+  const projectScriptsLibPath = path.join(projectPath, 'scripts', 'lib');
+  fs.mkdirSync(projectScriptsLibPath, { recursive: true });
+  copyDir(rootLibPath, projectScriptsLibPath);
+
+  // Verify marp.themeSet configuration exists in package.json
+  ThemeManager.ensureThemeSetConfig(projectPath);
+
+  console.log('✓ Project created');
+
+  // Copy optional files
+  if (createExamples) {
+    copyOptionalFiles(projectPath);
+    console.log('✓ Example slides added');
+    console.log('✓ Demo image added to static/');
+  }
+
+  // Copy theme management documentation
+  const themeDocsSource = path.join(__dirname, '../..', 'docs', 'theme-management.md');
+  const themeDocsDest = path.join(projectPath, 'docs', 'theme-management.md');
+  if (fs.existsSync(themeDocsSource)) {
+    fs.mkdirSync(path.dirname(themeDocsDest), { recursive: true });
+    fs.copyFileSync(themeDocsSource, themeDocsDest);
+    console.log('✓ Theme management guide added');
+  }
+
+  // Add themes to project (prompts user interactively if TTY)
+  let copied = [];
+  if (process.stdin.isTTY) {
+    // Interactive mode - prompt for themes
+    console.log();
+    const command = new AddThemesCommand({
+      templatePath: themesLibraryPath,
+      interactive: true
+    });
+
+    const result = await command.execute(projectPath, {
+      themes: null  // Triggers built-in prompt
+    });
+    copied = result.copied;
+  }
+  // Non-interactive mode: skip theme addition entirely
+
+  // Select and set active theme from copied themes
+  if (copied && copied.length > 0) {
+    console.log();
+    const themeNames = copied.map(t => t.name);
+    const activeTheme = await Prompts.promptActiveTheme(themeNames);
+    const themeManager = new ThemeManager(projectPath);
+    try {
+      themeManager.setActiveTheme(activeTheme);
+      console.log(`✓ Set active theme to "${activeTheme}"`);
+    } catch (error) {
+      console.warn(`  Warning: Could not set active theme: ${error.message}`);
+    }
+  } else {
+    // No themes copied, set default active theme
+    const themeManager = new ThemeManager(projectPath);
+    try {
+      themeManager.setActiveTheme('default');
+      console.log(`✓ Set active theme to "default"`);
+    } catch (error) {
+      console.warn(`  Warning: Could not set active theme: ${error.message}`);
+    }
+  }
+
+  console.log();
+
+  // Run npm install
+  console.log('Installing dependencies...');
+  const installResult = spawnSync('npm', ['install'], {
+    cwd: projectPath,
+    stdio: 'inherit',
+  });
+
+  if (installResult.status !== 0) {
+    console.error();
+    console.error('Failed to install dependencies.');
+    console.error('Please run "cd ' + projectName + ' && npm install" manually.');
+    throw new Error('npm install failed');
+  }
+
+  console.log();
+  console.log('✓ Dependencies installed');
+  console.log();
+  console.log('Next steps:');
+  const cwdRelativePath = path.relative(process.cwd(), projectPath);
+  const cdPath = cwdRelativePath.startsWith('..') ? projectPath : cwdRelativePath;
+  const readmePath = path.join(cdPath, 'README.md');
+  console.log(`  cd ${cdPath}`);
+  console.log('  npm run dev        # Start live preview');
+  console.log('  npm run theme:list # List available themes');
+  console.log('  npm run theme:set <theme-name> # Set active theme');
+  console.log('  npm run theme:add  # Add more themes to the project');
+  console.log('  npm run build:all  # Build all formats');
+  console.log('  Open project folder in vscode with Marp extension for editing your presentation');
+  console.log(`  Read ${readmePath} for more information`);
+  console.log('  Enjoy!');
+  console.log();
+}
+
+module.exports = {
+  createProject,
+  validateProjectName,
+  parsePathArg
+};

package/cli/utils/file-utils.js

@@ -0,0 +1,106 @@
+// cli/utils/file-utils.js
+/**
+ * File and directory utilities for meta-package CLI commands
+ * These functions are NOT copied to generated projects
+ */
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+/**
+ * Expand ~ to home directory
+ * @param {string} input - Path that may start with ~
+ * @returns {string} Expanded path
+ */
+function expandHomePath(input) {
+  if (input.startsWith('~')) {
+    return path.join(os.homedir(), input.slice(1));
+  }
+  return input;
+}
+
+/**
+ * Validate and normalize an output directory path
+ * @param {string} inputPath - Path to validate
+ * @returns {{valid: boolean, error?: string, resolvedPath?: string}} Validation result
+ */
+function validateOutputPath(inputPath) {
+  if (!inputPath || inputPath.trim() === '') {
+    return { valid: false, error: 'Path cannot be empty' };
+  }
+
+  // Check for null bytes (security)
+  if (inputPath.includes('\0')) {
+    return { valid: false, error: 'Path contains null bytes' };
+  }
+
+  const expanded = expandHomePath(inputPath);
+  const resolved = path.resolve(expanded);
+  const normalizedResolved = resolved.toLowerCase();
+
+  // Block system-sensitive directories
+  const sensitiveDirs = ['/etc', '/sys', '/proc', '/root', '/boot'];
+  for (const sensitive of sensitiveDirs) {
+    if (normalizedResolved.startsWith(sensitive.toLowerCase() + path.sep) ||
+        normalizedResolved === sensitive.toLowerCase()) {
+      return { valid: false, error: `Cannot create project in system directory: ${sensitive}` };
+    }
+  }
+
+  // Don't allow creation inside node_modules
+  if (normalizedResolved.includes('node_modules')) {
+    return { valid: false, error: 'Cannot create project inside node_modules directory' };
+  }
+
+  return { valid: true, resolvedPath: resolved };
+}
+
+/**
+ * Recursively copy a directory
+ * @param {string} src - Source directory path
+ * @param {string} dest - Destination directory path
+ */
+function copyDir(src, dest) {
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      fs.mkdirSync(destPath, { recursive: true });
+      copyDir(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+/**
+ * Copy optional template files to destination
+ * @param {string} destPath - Destination project path
+ */
+function copyOptionalFiles(destPath) {
+  const optionalPath = path.join(__dirname, '..', '..', 'template-optional');
+
+  // Copy examples.md
+  const examplesSrc = path.join(optionalPath, 'examples.md');
+  const examplesDest = path.join(destPath, 'examples.md');
+  if (fs.existsSync(examplesSrc)) {
+    fs.copyFileSync(examplesSrc, examplesDest);
+  }
+
+  // Copy demo image
+  const demoImageSrc = path.join(optionalPath, 'static', 'demo-image.png');
+  const demoImageDest = path.join(destPath, 'static', 'demo-image.png');
+  if (fs.existsSync(demoImageSrc)) {
+    fs.copyFileSync(demoImageSrc, demoImageDest);
+  }
+}
+
+module.exports = {
+  expandHomePath,
+  validateOutputPath,
+  copyDir,
+  copyOptionalFiles
+};

package/cli/utils/prompt-utils.js

@@ -0,0 +1,89 @@
+// cli/utils/prompt-utils.js
+/**
+ * Prompt utilities for meta-package CLI commands
+ * These functions are NOT copied to generated projects
+ */
+const readline = require('readline');
+
+/**
+ * Ask user if they want to create example slides
+ * @returns {Promise<boolean>} True if user wants examples
+ */
+async function askCreateExamples() {
+  return new Promise((resolve) => {
+    // Interactive mode - ask user
+    if (process.stdin.isTTY) {
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+
+      rl.question('Create example slides file? (Y/n) ', (answer) => {
+        rl.close();
+        const normalized = answer.toLowerCase().trim();
+        resolve(normalized !== 'n' && normalized !== 'no');
+      });
+    } else {
+      // Non-interactive mode - read from stdin if there's data
+      let input = '';
+      process.stdin.setEncoding('utf8');
+
+      process.stdin.on('readable', () => {
+        let chunk;
+        while ((chunk = process.stdin.read()) !== null) {
+          input += chunk;
+        }
+      });
+
+      process.stdin.on('end', () => {
+        const normalized = input.toLowerCase().trim();
+        // If input is empty, create examples by default
+        if (normalized === '') {
+          resolve(true);
+        } else {
+          resolve(normalized !== 'n' && normalized !== 'no');
+        }
+      });
+
+      // If stdin has no data immediately, finish
+      if (process.stdin.readableLength === 0) {
+        // Give a short time for data to appear
+        setTimeout(() => {
+          if (input === '') {
+            process.stdin.destroy();
+            resolve(true);
+          }
+        }, 10);
+      }
+    }
+  });
+}
+
+/**
+ * Ask user if they want to add themes to the project
+ * @returns {Promise<boolean>} True if user wants themes
+ */
+async function askAddThemes() {
+  return new Promise((resolve) => {
+    if (process.stdin.isTTY) {
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+
+      rl.question('Add custom themes to the project? (Y/n) ', (answer) => {
+        rl.close();
+        const normalized = answer.toLowerCase().trim();
+        resolve(normalized !== 'n' && normalized !== 'no');
+      });
+    } else {
+      // Non-interactive mode: default to false (don't add themes without consent)
+      resolve(false);
+    }
+  });
+}
+
+module.exports = {
+  askCreateExamples,
+  askAddThemes
+};