create-marp-presentation 1.0.1 → 1.2.0

package/README.md

@@ -1,34 +1,73 @@
 # Create Marp Presentation
 
-Создайте новую Marp презентацию одной командой.
+Create beautiful presentations in Markdown. Zero setup.
 
-## Установка
+## Quick Start
 
 ```bash
 npx create-marp-presentation my-presentation
+cd my-presentation
+npm run dev
 ```
 
-## Использование
+That's it! Edit `presentation.md` and see changes live at `http://localhost:8080`.
+
+## VSCode Setup
+
+For the best editing experience, install [Marp for VSCode](https://marketplace.visualstudio.com/items?itemName=marp-team.marp-vscode):
+
+1. Open VSCode
+2. Press `Ctrl+Shift+X` (or `Cmd+Shift+X` on Mac)
+3. Search "Marp for VSCode"
+4. Click Install
+
+After installing, open any `.md` file and click the **Marp: Preview** button in the top-right corner.
+
+## What You Get
+
+- **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
+
+## Commands
+
+| 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 |
+
+## Theme Management
+
+Add and switch themes anytime.
+
+### Quick Theme Commands
 
 ```bash
-cd my-presentation
-npm run dev     # Live preview
-npm run build:all  # Build all formats
+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
 ```
 
-## Возможности
+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)
 
-- 🚀 One-command setup
-- 📝 Markdown slides
-- 🎨 Marp themes
-- 📦 HTML, PDF, PPTX export
-- 📁 Static files support
-- 🔥 Live preview
+## Local Development
 
-## Документация
+To test without publishing to npm:
 
-После создания проекта читайте README в папке проекта.
+```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
 
 MIT

package/index.js

@@ -1,96 +1,131 @@
 #!/usr/bin/env node
 
-const fs = require('fs');
-const path = require('path');
-const { spawnSync } = require('child_process');
+/**
+ * create-marp-presentation - CLI entry point
+ * Supports dual entry points:
+ *   1. npx create-marp-presentation <name> [--path <dir>] - Create new project
+ *   2. npx create-marp-presentation theme:add <path> [themes...] - Add themes to existing project
+ */
 
-const projectName = process.argv[2];
+const path = require('path');
 
-if (!projectName) {
-  console.error('Please provide a project name:');
-  console.error('  npx create-marp-presentation <project-name>');
-  process.exit(1);
-}
+const { createProject, validateProjectName, parsePathArg } = require('./cli/commands/create-project');
+const { addThemesToExistingProject } = require('./cli/commands/add-themes-cli');
+const { validateOutputPath } = require('./cli/utils/file-utils');
 
-// Валидация имени проекта
-const validName = /^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]$/;
-if (!validName.test(projectName)) {
-  console.error(`Invalid project name: "${projectName}"`);
-  console.error('Project name must be lowercase, contain only letters, numbers, and hyphens.');
-  process.exit(1);
+// Paths
+const templatePath = path.join(__dirname, 'template');
+const themesLibraryPath = path.join(__dirname, 'themes');
+
+/**
+ * Show usage information
+ * @param {boolean} isError - If true, write to stderr and exit with error code
+ */
+function showUsage(isError = false) {
+  const output = isError ? console.error : console.log;
+  output('Please provide a project name:');
+  output('  npx create-marp-presentation <project-name> [--path <output-dir>]');
+  output('');
+  output('Or use the theme:add command:');
+  output('  npx create-marp-presentation theme:add <project-path> [theme-names...]');
+  output('');
+  output('Examples:');
+  output('  npx create-marp-presentation my-project');
+  output('  npx create-marp-presentation my-project --path /tmp');
+  output('  npx create-marp-presentation my-project --path ~/projects');
+  output('  npx create-marp-presentation theme:add ./my-project');
+  output('  npx create-marp-presentation theme:add ./my-project beam marpx');
+  output('');
+
+  if (isError) {
+    process.exit(1);
+  }
 }
 
-const projectPath = path.join(process.cwd(), projectName);
+/**
+ * Handle theme:add command
+ * @param {string[]} args - Command arguments
+ */
+async function handleThemeAdd(args) {
+  const targetPath = args[0];
+  if (!targetPath) {
+    console.error('Usage: npx create-marp-presentation theme:add <project-path> [theme-names...]');
+    process.exit(1);
+  }
 
-// Validate path to prevent traversal attacks
-const resolvedPath = path.resolve(projectPath);
-if (!resolvedPath.startsWith(path.resolve(process.cwd()))) {
-  console.error('Invalid project path: path traversal detected.');
-  process.exit(1);
-}
+  const themeNames = args.slice(1); // Additional arguments are theme names
 
-// Проверка существования папки
-if (fs.existsSync(projectPath)) {
-  console.error(`Directory "${projectName}" already exists.`);
-  process.exit(1);
+  try {
+    await addThemesToExistingProject(targetPath, {
+      themesLibraryPath,
+      themeNames: themeNames.length > 0 ? themeNames : null
+    });
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
 }
 
-// Получаем путь к template
-const templatePath = path.join(__dirname, 'template');
-
-console.log(`Creating Marp presentation: ${projectName}`);
-console.log();
-
-try {
-  // Создаём папку проекта
-  fs.mkdirSync(projectPath, { recursive: true });
-
-  // Рекурсивно копируем template
-  const 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);
-      }
+/**
+ * Handle project creation command
+ * @param {string} projectName - Name of the project
+ * @param {string[]} args - Remaining arguments (e.g., --path)
+ */
+async function handleProjectCreation(projectName, args = []) {
+  // Parse --path argument if present
+  const { pathIndex } = parsePathArg(args);
+  let outputPath = process.cwd();
+
+  if (pathIndex !== null) {
+    const pathArg = args[pathIndex + 1];
+    const validation = validateOutputPath(pathArg);
+    if (!validation.valid) {
+      console.error(`Invalid --path: "${pathArg}"`);
+      console.error(validation.error);
+      process.exit(1);
     }
-  };
-
-  copyDir(templatePath, projectPath);
-
-  console.log('✓ Project created');
-  console.log();
-
-  // Запускаем npm install
-  console.log('Installing dependencies...');
-  const installResult = spawnSync('npm', ['install'], {
-    cwd: projectPath,
-    stdio: 'inherit',
-  });
+    outputPath = validation.resolvedPath;
+  }
 
-  if (installResult.status !== 0) {
-    console.error();
-    console.error('Failed to install dependencies.');
-    console.error('Please run "cd ' + projectName + ' && npm install" manually.');
+  try {
+    await createProject(projectName, {
+      outputPath,
+      templatePath,
+      themesLibraryPath
+    });
+  } catch (error) {
+    if (error.message === 'Invalid project name' || error.message === 'Project directory already exists') {
+      process.exit(1);
+    }
+    console.error('Error creating project:', error.message);
     process.exit(1);
   }
+}
 
-  console.log();
-  console.log('✓ Dependencies installed');
-  console.log();
-  console.log('Next steps:');
-  console.log(`  cd ${projectName}`);
-  console.log('  npm run dev     # Start live preview');
-  console.log('  npm run build:all  # Build all formats');
-  console.log();
-
-} catch (err) {
-  console.error('Error creating project:', err.message);
-  process.exit(1);
+/**
+ * Main entry point
+ */
+async function main() {
+  const [command, ...args] = process.argv.slice(2);
+
+  switch (command) {
+    case 'theme:add':
+      await handleThemeAdd(args);
+      break;
+
+    case undefined:
+      showUsage(true); // Exit with error code 1
+      break;
+
+    default:
+      // Treat as project name (backward compatible)
+      await handleProjectCreation(command, args);
+      break;
+  }
 }
+
+// Run
+main().catch(error => {
+  console.error('Unexpected error:', error.message);
+  process.exit(1);
+});

package/lib/add-themes-command.js

@@ -0,0 +1,381 @@
+// lib/add-themes-command.js
+const fs = require('fs');
+const path = require('path');
+const { ThemeResolver, Theme } = require('./theme-resolver');
+const { VSCodeIntegration, VSCodeSettingsDTO } = require('./vscode-integration');
+const { ThemeManager } = require('./theme-manager');
+const { Prompts } = require('./prompts');
+const {
+  ThemeError,
+  ThemeNotFoundError,
+  ThemeAlreadyExistsError
+} = require('./errors');
+
+/**
+ * Shared function for adding Marp themes to a project
+ * Handles theme copying, dependency resolution, conflict detection, and VSCode sync
+ */
+class AddThemesCommand {
+  /**
+   * @param {Object} options - Configuration options
+   * @param {string} options.templatePath - Path to themes library directory (optional, defaults to __dirname/../themes)
+   * @param {boolean} options.interactive - Enable interactive prompts (default: true)
+   * @param {Object} options.prompts - Prompt functions for testing (optional)
+   */
+  constructor(options = {}) {
+    this.options = {
+      interactive: options.interactive !== false,
+      templatePath: options.templatePath || path.join(__dirname, '..', 'themes'),
+      ...options
+    };
+  }
+
+  /**
+   * Returns the path to the themes library directory
+   * @returns {string} Absolute path to themes library
+   */
+  getTemplateThemesPath() {
+    // templatePath now points directly to the themes library
+    return this.options.templatePath;
+  }
+
+  /**
+   * Main execution method - adds themes to target project
+   *
+   * @param {string} targetPath - Path to target project directory
+   * @param {Object} options - Execution options
+   * @param {string[]} options.themes - Theme names to add (optional, prompts if not provided)
+   * @param {string[]} options.skip - Theme names to skip conflicts (optional)
+   * @param {boolean} options.force - Overwrite existing themes (default: false)
+   * @param {boolean} options.noVscode - Skip VSCode settings sync (default: false)
+   * @returns {Promise<Object>} Result object with copied, skipped, and conflicts arrays
+   */
+  async execute(targetPath, options = {}) {
+    const execOptions = {
+      themes: options.themes || null,
+      skip: options.skip || [],
+      force: options.force || false,
+      noVscode: options.noVscode || false,
+      ...options
+    };
+
+    // Validate target path
+    if (!fs.existsSync(targetPath)) {
+      throw new ThemeError(`Target path does not exist: ${targetPath}`);
+    }
+
+    const templateThemesPath = this.getTemplateThemesPath();
+
+    // Scan available themes from themes library
+    if (!fs.existsSync(templateThemesPath)) {
+      throw new ThemeError(`Themes library directory not found: ${templateThemesPath}`);
+    }
+
+    const availableThemes = ThemeResolver.scanDirectory(templateThemesPath);
+
+    if (availableThemes.length === 0) {
+      throw new ThemeError('No themes found in themes library');
+    }
+
+    // Determine which themes to copy
+    let themesToCopy;
+    if (execOptions.themes != null) {
+      // themes explicitly provided (even if empty array = copy nothing)
+      if (execOptions.themes.length > 0) {
+        themesToCopy = this._resolveThemeNames(execOptions.themes, availableThemes);
+      } else {
+        // Empty array means user chose no themes
+        themesToCopy = [];
+      }
+    } else if (this.options.interactive) {
+      // Interactive mode - prompt user using built-in Prompts.promptThemes()
+      const selectedNames = await this._promptThemes(availableThemes);
+      // Filter availableThemes to only include selected ones
+      themesToCopy = availableThemes.filter(t => selectedNames.includes(t.name));
+    } else {
+      // Non-interactive without explicit themes: copy all available themes
+      themesToCopy = availableThemes;
+    }
+
+    // Resolve dependencies
+    const themesWithDependencies = ThemeResolver.resolveDependencies(
+      themesToCopy,
+      availableThemes
+    );
+
+    // Scan existing themes in project
+    const existingThemes = this._scanProjectThemes(targetPath);
+
+    // Find conflicts
+    const conflicts = this._findConflicts(themesWithDependencies, existingThemes);
+
+    // Handle conflicts
+    let skipList = new Set(execOptions.skip);
+
+    if (conflicts.length > 0 && !execOptions.force) {
+      if (this.options.interactive) {
+        const resolvedConflicts = await this._resolveConflictsInteractive(
+          conflicts,
+          execOptions.force
+        );
+        // Add overwrite choices to skip list (inverted logic - skip if not overwriting)
+        conflicts.forEach(conflict => {
+          if (!resolvedConflicts.overwrite.includes(conflict)) {
+            skipList.add(conflict);
+          }
+        });
+      } else {
+        // Non-interactive: skip all conflicts
+        conflicts.forEach(conflict => skipList.add(conflict));
+      }
+    }
+
+    // Copy themes
+    const copyResult = this.copyThemes(
+      themesWithDependencies,
+      templateThemesPath,
+      targetPath,
+      Array.from(skipList)
+    );
+
+    // Sync VSCode settings
+    if (!execOptions.noVscode && copyResult.copied.length > 0) {
+      this._syncVscodeSettings(targetPath, copyResult.copied);
+    }
+
+    // Ensure marp.themeSet is configured in package.json
+    if (copyResult.copied.length > 0) {
+      ThemeManager.ensureThemeSetConfig(targetPath, { silent: true });
+    }
+
+    // Return result with conflicts included
+    return {
+      ...copyResult,
+      conflicts
+    };
+  }
+
+  /**
+   * Copy themes from themes library to target project
+   *
+   * @param {Theme[]} themes - Theme objects to copy
+   * @param {string} templatePath - Path to themes library directory
+   * @param {string} targetPath - Path to target project directory
+   * @param {string[]} skipList - Theme names to skip
+   * @returns {Object} Result with copied, skipped arrays
+   */
+  copyThemes(themes, templatePath, targetPath, skipList = []) {
+    const skipSet = new Set(skipList);
+    const copied = [];
+    const skipped = [];
+
+    // Ensure target themes directory exists
+    const targetThemesDir = path.join(targetPath, 'themes');
+    if (!fs.existsSync(targetThemesDir)) {
+      fs.mkdirSync(targetThemesDir, { recursive: true });
+    }
+
+    for (const theme of themes) {
+      if (skipSet.has(theme.name)) {
+        skipped.push(theme.name);
+        continue;
+      }
+
+      // Calculate relative path from themes library
+      const relativePath = path.relative(templatePath, theme.path);
+      const targetFilePath = path.join(targetThemesDir, relativePath);
+
+      // Ensure target directory exists
+      const targetDir = path.dirname(targetFilePath);
+      if (!fs.existsSync(targetDir)) {
+        fs.mkdirSync(targetDir, { recursive: true });
+      }
+
+      // Copy file
+      fs.copyFileSync(theme.path, targetFilePath);
+      copied.push(theme);  // Return Theme object, not just name
+    }
+
+    return { copied, skipped };
+  }
+
+  /**
+   * Scan project themes directory for existing theme files
+   * @private
+   *
+   * @param {string} projectPath - Path to project directory
+   * @returns {Theme[]} Array of existing theme objects
+   */
+  _scanProjectThemes(projectPath) {
+    const themesPath = path.join(projectPath, 'themes');
+
+    if (!fs.existsSync(themesPath)) {
+      return [];
+    }
+
+    try {
+      return ThemeResolver.scanDirectory(themesPath);
+    } catch (error) {
+      // If scan fails, return empty array
+      return [];
+    }
+  }
+
+  /**
+   * Find conflicts between themes to copy and existing themes
+   * @private
+   *
+   * @param {Theme[]} themesToCopy - Themes that will be copied
+   * @param {Theme[]} existingThemes - Themes that already exist
+   * @returns {string[]} Array of conflicting theme names
+   */
+  _findConflicts(themesToCopy, existingThemes) {
+    const existingNames = new Set(existingThemes.map(t => t.name));
+    const conflicts = [];
+
+    for (const theme of themesToCopy) {
+      if (existingNames.has(theme.name)) {
+        conflicts.push(theme.name);
+      }
+    }
+
+    return conflicts;
+  }
+
+  /**
+   * Resolve theme names to Theme objects
+   * @private
+   *
+   * @param {string[]} themeNames - Theme names to resolve
+   * @param {Theme[]} availableThemes - Available themes from themes library
+   * @returns {Theme[]} Resolved theme objects
+   * @throws {ThemeNotFoundError} If a theme name is not found
+   */
+  _resolveThemeNames(themeNames, availableThemes) {
+    const themesMap = new Map();
+    for (const theme of availableThemes) {
+      themesMap.set(theme.name, theme);
+    }
+
+    const resolved = [];
+    const notFound = [];
+
+    for (const name of themeNames) {
+      const theme = themesMap.get(name);
+      if (theme) {
+        resolved.push(theme);
+      } else {
+        notFound.push(name);
+      }
+    }
+
+    if (notFound.length > 0) {
+      const message = notFound.length === 1
+        ? notFound[0]
+        : `${notFound.join(', ')}`;
+      throw new ThemeNotFoundError(message);
+    }
+
+    return resolved;
+  }
+
+  /**
+   * Prompt user to select themes interactively
+   * Uses Prompts.promptThemes() for built-in theme selection
+   * @private
+   *
+   * @param {Theme[]} availableThemes - Available themes
+   * @returns {Promise<string[]>} Selected theme names
+   */
+  async _promptThemes(availableThemes) {
+    // Use built-in Prompts.promptThemes() for interactive selection
+    return await Prompts.promptThemes(availableThemes);
+  }
+
+  /**
+   * Resolve conflicts interactively
+   * @private
+   *
+   * @param {string[]} conflicts - Conflicting theme names
+   * @param {boolean} force - Force overwrite all
+   * @returns {Promise<Object>} Resolution result with overwrite array
+   */
+  async _resolveConflictsInteractive(conflicts, force) {
+    if (force) {
+      return { overwrite: conflicts };
+    }
+
+    // Use custom prompt if provided (backward compatibility for tests)
+    if (this.options.prompts?.resolveConflicts) {
+      return await this.options.prompts.resolveConflicts(conflicts);
+    }
+
+    // Use built-in Prompts.promptConflictResolution
+    const result = await Prompts.promptConflictResolution(
+      conflicts.map(c => ({ name: c }))
+    );
+
+    if (result === 'skip-all') return { overwrite: [] };
+    if (result === 'overwrite-all') return { overwrite: conflicts };
+    if (result === 'cancel') return { overwrite: [] };
+
+    // Handle 'choose-each' or individual conflicts
+    const overwrite = [];
+    for (const conflict of conflicts) {
+      const choice = await Prompts.promptSingleConflict(conflict);
+      if (choice === 'overwrite') {
+        overwrite.push(conflict);
+      } else if (choice === 'cancel') {
+        break;
+      }
+    }
+    return { overwrite };
+  }
+
+  /**
+   * Sync themes to VSCode settings
+   * @private
+   *
+   * @param {string} projectPath - Path to project directory
+   * @param {string[]} copiedThemes - Names of copied themes
+   */
+  _syncVscodeSettings(projectPath, copiedThemes) {
+    const vscode = new VSCodeIntegration(projectPath);
+
+    // Use DTO for type-safe access
+    const dto = vscode.createSettingsDTO();
+    const existingThemes = dto.getMarpThemes();
+
+    // Add new theme paths (relative to themes/)
+    // copiedThemes are Theme objects - use their paths to compute relative paths
+    const newThemePaths = copiedThemes.map(theme => {
+      // theme.path is absolute, we need relative path from themes directory
+      // e.g., /library/themes/marpx/socrates.css -> themes/marpx/socrates.css
+      const filename = path.basename(theme.path);
+      const themeName = path.basename(path.dirname(theme.path));
+      // For single-file themes: themes/themeName/themeName.css
+      // For themes in subdirs: themes/subdir/themeName.css
+      return `themes/${themeName}/${filename}`;
+    });
+
+    // Merge without duplicates
+    const allThemes = [...new Set([...existingThemes, ...newThemePaths])];
+
+    dto.setMarpThemes(allThemes);
+    vscode.writeSettings(dto.toObject());
+  }
+}
+
+/**
+ * Convenience function to create and execute AddThemesCommand
+ *
+ * @param {string} targetPath - Path to target project directory
+ * @param {Object} options - Options passed to AddThemesCommand
+ * @returns {Promise<Object>} Result object from execute()
+ */
+async function addThemesCommand(targetPath, options = {}) {
+  const command = new AddThemesCommand(options);
+  return await command.execute(targetPath, options);
+}
+
+module.exports = { AddThemesCommand, addThemesCommand };