@litodocs/cli 0.6.0 → 1.0.0

package/src/commands/init.js

@@ -0,0 +1,284 @@
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { resolve, join } from 'path';
+import { intro, outro, text, select, confirm, spinner, log, isCancel, cancel } from '@clack/prompts';
+import pc from 'picocolors';
+import { TEMPLATE_REGISTRY } from '../core/template-registry.js';
+
+/**
+ * Default docs-config.json template
+ */
+function createDefaultConfig(projectName, framework) {
+  return {
+    metadata: {
+      name: projectName,
+      description: `Documentation for ${projectName}`,
+    },
+    branding: {
+      colors: {
+        primary: '#10b981',
+        accent: '#3b82f6',
+      },
+    },
+    navigation: {
+      navbar: {
+        links: [
+          { label: 'Docs', href: '/' },
+          { label: 'GitHub', href: 'https://github.com' },
+        ],
+      },
+      sidebar: [
+        {
+          label: 'Getting Started',
+          items: [
+            { label: 'Introduction', href: '/introduction' },
+            { label: 'Quick Start', href: '/quickstart' },
+          ],
+        },
+      ],
+    },
+    search: {
+      enabled: true,
+    },
+  };
+}
+
+/**
+ * Sample introduction page content
+ */
+function createIntroductionPage(projectName) {
+  return `---
+title: Introduction
+description: Welcome to ${projectName}
+---
+
+# Welcome to ${projectName}
+
+This is your documentation home. Edit this file at \`introduction.mdx\` to get started.
+
+## Features
+
+<CardGroup cols={2}>
+  <Card title="Fast" icon="bolt">
+    Built for speed with static site generation
+  </Card>
+  <Card title="Flexible" icon="puzzle-piece">
+    Customize with MDX components
+  </Card>
+</CardGroup>
+
+## Next Steps
+
+- Read the [Quick Start](/quickstart) guide
+- Explore the MDX components available
+- Customize your \`docs-config.json\`
+`;
+}
+
+/**
+ * Sample quickstart page content
+ */
+function createQuickstartPage(projectName) {
+  return `---
+title: Quick Start
+description: Get up and running with ${projectName}
+---
+
+# Quick Start
+
+Get your documentation site running in minutes.
+
+## Installation
+
+<Steps>
+  <Step title="Install Lito CLI">
+    \`\`\`bash
+    npm install -g @aspect-ui/lito
+    \`\`\`
+  </Step>
+
+  <Step title="Start Development Server">
+    \`\`\`bash
+    lito dev -i ./docs
+    \`\`\`
+  </Step>
+
+  <Step title="Build for Production">
+    \`\`\`bash
+    lito build -i ./docs -o ./dist
+    \`\`\`
+  </Step>
+</Steps>
+
+## Configuration
+
+Edit \`docs-config.json\` to customize your site:
+
+\`\`\`json
+{
+  "metadata": {
+    "name": "${projectName}",
+    "description": "Your project description"
+  }
+}
+\`\`\`
+
+> [!TIP]
+> Run \`lito validate\` to check your configuration for errors.
+`;
+}
+
+/**
+ * Init command - Initialize a new documentation project
+ */
+export async function initCommand(options) {
+  try {
+    console.clear();
+    intro(pc.inverse(pc.cyan(' Lito - Initialize New Project ')));
+
+    // Determine output directory
+    let outputDir = options.output ? resolve(options.output) : null;
+
+    if (!outputDir) {
+      const dirAnswer = await text({
+        message: 'Where should we create your docs?',
+        placeholder: './docs',
+        defaultValue: './docs',
+        validate: (value) => {
+          if (!value) return 'Please enter a directory path';
+        },
+      });
+
+      if (isCancel(dirAnswer)) {
+        cancel('Operation cancelled.');
+        process.exit(0);
+      }
+
+      outputDir = resolve(dirAnswer);
+    }
+
+    // Check if directory exists and has content
+    if (existsSync(outputDir)) {
+      const files = await import('fs').then(fs => fs.readdirSync(outputDir));
+      if (files.length > 0) {
+        const overwrite = await confirm({
+          message: `Directory ${pc.cyan(outputDir)} is not empty. Continue anyway?`,
+          initialValue: false,
+        });
+
+        if (isCancel(overwrite) || !overwrite) {
+          cancel('Operation cancelled.');
+          process.exit(0);
+        }
+      }
+    }
+
+    // Project name
+    let projectName = options.name;
+    if (!projectName) {
+      const nameAnswer = await text({
+        message: 'What is your project name?',
+        placeholder: 'My Docs',
+        defaultValue: 'My Docs',
+      });
+
+      if (isCancel(nameAnswer)) {
+        cancel('Operation cancelled.');
+        process.exit(0);
+      }
+
+      projectName = nameAnswer;
+    }
+
+    // Framework/template selection
+    const templates = Object.keys(TEMPLATE_REGISTRY);
+    let selectedTemplate = options.template;
+
+    if (!selectedTemplate) {
+      const templateAnswer = await select({
+        message: 'Which template would you like to use?',
+        options: templates.map((t) => ({
+          value: t,
+          label: t === 'default' ? `${t} (Astro - Recommended)` : t,
+          hint: TEMPLATE_REGISTRY[t],
+        })),
+      });
+
+      if (isCancel(templateAnswer)) {
+        cancel('Operation cancelled.');
+        process.exit(0);
+      }
+
+      selectedTemplate = templateAnswer;
+    }
+
+    // Create sample content?
+    let createSample = options.sample !== false;
+    if (!options.sample) {
+      const sampleAnswer = await confirm({
+        message: 'Create sample documentation pages?',
+        initialValue: true,
+      });
+
+      if (isCancel(sampleAnswer)) {
+        cancel('Operation cancelled.');
+        process.exit(0);
+      }
+
+      createSample = sampleAnswer;
+    }
+
+    // Create project
+    const s = spinner();
+    s.start('Creating project structure...');
+
+    // Create directories
+    mkdirSync(outputDir, { recursive: true });
+    mkdirSync(join(outputDir, '_assets'), { recursive: true });
+    mkdirSync(join(outputDir, '_images'), { recursive: true });
+
+    // Create docs-config.json
+    const config = createDefaultConfig(projectName, selectedTemplate);
+    writeFileSync(
+      join(outputDir, 'docs-config.json'),
+      JSON.stringify(config, null, 2)
+    );
+
+    // Create sample pages if requested
+    if (createSample) {
+      writeFileSync(
+        join(outputDir, 'introduction.mdx'),
+        createIntroductionPage(projectName)
+      );
+      writeFileSync(
+        join(outputDir, 'quickstart.mdx'),
+        createQuickstartPage(projectName)
+      );
+    }
+
+    s.stop('Project created');
+
+    // Success message
+    log.success(pc.green('Project initialized successfully!'));
+    log.message('');
+    log.message(pc.bold('Next steps:'));
+    log.message('');
+    log.message(`  ${pc.cyan('cd')} ${outputDir}`);
+    log.message(`  ${pc.cyan('lito dev')} -i .`);
+    log.message('');
+    log.message(pc.dim(`Template: ${selectedTemplate}`));
+    log.message(pc.dim(`Config: ${join(outputDir, 'docs-config.json')}`));
+
+    outro(pc.green('Happy documenting! 📚'));
+  } catch (error) {
+    if (isCancel(error)) {
+      cancel('Operation cancelled.');
+      process.exit(0);
+    }
+
+    log.error(pc.red(error.message));
+    if (error.stack) {
+      log.error(pc.gray(error.stack));
+    }
+    process.exit(1);
+  }
+}

package/src/commands/preview.js

@@ -0,0 +1,98 @@
+import { existsSync } from 'fs';
+import { resolve, join } from 'path';
+import { intro, log, spinner, isCancel, cancel } from '@clack/prompts';
+import pc from 'picocolors';
+import { execa } from 'execa';
+
+/**
+ * Preview command - Build and preview production site locally
+ */
+export async function previewCommand(options) {
+  try {
+    const inputPath = options.input ? resolve(options.input) : null;
+    const outputPath = resolve(options.output || './dist');
+    const port = options.port || '4321';
+
+    console.clear();
+    intro(pc.inverse(pc.cyan(' Lito - Preview Production Build ')));
+
+    const s = spinner();
+
+    // Check if dist exists, if not run build first
+    if (!existsSync(outputPath)) {
+      if (!inputPath) {
+        log.error(`Output directory ${pc.cyan(outputPath)} does not exist.`);
+        log.message('');
+        log.message('Either:');
+        log.message(`  1. Run ${pc.cyan('lito build -i <docs>')} first`);
+        log.message(`  2. Use ${pc.cyan('lito preview -i <docs>')} to build and preview`);
+        process.exit(1);
+      }
+
+      log.warn(`Output directory not found. Building first...`);
+      log.message('');
+
+      // Run build command
+      const { buildCommand } = await import('./build.js');
+      await buildCommand({
+        input: inputPath,
+        output: outputPath,
+        template: options.template || 'default',
+        baseUrl: options.baseUrl || '/',
+        provider: 'static',
+      });
+
+      console.clear();
+      intro(pc.inverse(pc.cyan(' Lito - Preview Production Build ')));
+    }
+
+    // Check for index.html in output
+    const indexPath = join(outputPath, 'index.html');
+    if (!existsSync(indexPath)) {
+      log.error(`No index.html found in ${pc.cyan(outputPath)}`);
+      log.message('This directory may not contain a valid build output.');
+      process.exit(1);
+    }
+
+    log.success(`Serving ${pc.cyan(outputPath)}`);
+    log.message('');
+    log.message(`  ${pc.bold('Local:')}   ${pc.cyan(`http://localhost:${port}`)}`);
+    log.message('');
+    log.message(pc.dim('Press Ctrl+C to stop'));
+    log.message('');
+
+    // Use npx serve or a simple HTTP server
+    try {
+      // Try using 'serve' package
+      await execa('npx', ['serve', outputPath, '-l', port], {
+        stdio: 'inherit',
+        cwd: process.cwd(),
+      });
+    } catch (serveError) {
+      // Fallback to Python's http.server if serve isn't available
+      try {
+        await execa('python3', ['-m', 'http.server', port, '-d', outputPath], {
+          stdio: 'inherit',
+          cwd: process.cwd(),
+        });
+      } catch (pythonError) {
+        log.error('Could not start preview server.');
+        log.message('');
+        log.message('Please install a static server:');
+        log.message(`  ${pc.cyan('npm install -g serve')}`);
+        log.message('');
+        log.message('Or manually serve the output:');
+        log.message(`  ${pc.cyan(`npx serve ${outputPath}`)}`);
+        process.exit(1);
+      }
+    }
+  } catch (error) {
+    if (isCancel(error)) {
+      cancel('Preview stopped.');
+      process.exit(0);
+    }
+
+    log.error(pc.red(error.message));
+    process.exit(1);
+  }
+}

package/src/commands/validate.js

@@ -0,0 +1,124 @@
+import { existsSync, readFileSync } from 'fs';
+import { resolve, join } from 'path';
+import { intro, outro, log, spinner } from '@clack/prompts';
+import pc from 'picocolors';
+import { validateConfig, isPortableConfig, getCoreConfigKeys, getExtensionKeys } from '../core/config-validator.js';
+
+/**
+ * Validate command - Validate docs-config.json
+ */
+export async function validateCommand(options) {
+  try {
+    const inputPath = options.input ? resolve(options.input) : process.cwd();
+    const configPath = join(inputPath, 'docs-config.json');
+
+    // Quick mode for CI - just exit with code
+    if (options.quiet) {
+      if (!existsSync(configPath)) {
+        process.exit(1);
+      }
+      try {
+        const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+        const result = validateConfig(config, inputPath, { silent: true });
+        process.exit(result.valid ? 0 : 1);
+      } catch (e) {
+        process.exit(1);
+      }
+    }
+
+    console.clear();
+    intro(pc.inverse(pc.cyan(' Lito - Validate Configuration ')));
+
+    const s = spinner();
+
+    // Check if config file exists
+    s.start('Looking for docs-config.json...');
+
+    if (!existsSync(configPath)) {
+      s.stop(pc.red('Configuration file not found'));
+      log.error(`No docs-config.json found at ${pc.cyan(inputPath)}`);
+      log.message('');
+      log.message(`Run ${pc.cyan('lito init')} to create a new project with a config file.`);
+      process.exit(1);
+    }
+
+    s.stop(`Found: ${pc.cyan(configPath)}`);
+
+    // Parse JSON
+    s.start('Parsing configuration...');
+    let config;
+    try {
+      config = JSON.parse(readFileSync(configPath, 'utf-8'));
+      s.stop('Configuration parsed');
+    } catch (parseError) {
+      s.stop(pc.red('Invalid JSON'));
+      log.error('Failed to parse docs-config.json:');
+      log.error(pc.red(parseError.message));
+      process.exit(1);
+    }
+
+    // Validate
+    s.start('Validating configuration...');
+    const result = validateConfig(config, inputPath, { silent: true });
+
+    if (!result.valid) {
+      s.stop(pc.red('Validation failed'));
+      log.message('');
+      log.error(pc.bold('Configuration errors:'));
+      for (const error of result.errors) {
+        log.error(`  ${pc.red('•')} ${pc.yellow(error.path)}: ${error.message}`);
+      }
+      log.message('');
+      process.exit(1);
+    }
+
+    s.stop(pc.green('Configuration is valid'));
+
+    // Show summary
+    log.message('');
+    log.success(pc.bold('Configuration Summary:'));
+    log.message('');
+
+    // Metadata
+    if (config.metadata) {
+      log.message(`  ${pc.cyan('Name:')} ${config.metadata.name || pc.dim('(not set)')}`);
+      if (config.metadata.description) {
+        log.message(`  ${pc.cyan('Description:')} ${config.metadata.description}`);
+      }
+    }
+
+    // Navigation
+    if (config.navigation) {
+      const sidebarGroups = config.navigation.sidebar?.length || 0;
+      const navbarLinks = config.navigation.navbar?.links?.length || 0;
+      log.message(`  ${pc.cyan('Sidebar groups:')} ${sidebarGroups}`);
+      log.message(`  ${pc.cyan('Navbar links:')} ${navbarLinks}`);
+    }
+
+    // Features
+    log.message('');
+    log.message(pc.bold('  Features:'));
+    log.message(`    ${config.search?.enabled ? pc.green('✓') : pc.dim('○')} Search`);
+    log.message(`    ${config.i18n?.enabled ? pc.green('✓') : pc.dim('○')} i18n`);
+    log.message(`    ${config.versioning?.enabled ? pc.green('✓') : pc.dim('○')} Versioning`);
+
+    // Portability check
+    log.message('');
+    const portable = isPortableConfig(config);
+    if (portable) {
+      log.message(`  ${pc.green('✓')} ${pc.dim('Portable config (works with any template)')}`);
+    } else {
+      const usedExtensions = getExtensionKeys().filter(key => key in config);
+      log.message(`  ${pc.yellow('!')} ${pc.dim(`Uses template extensions: ${usedExtensions.join(', ')}`)}`);
+    }
+
+    log.message('');
+    outro(pc.green('Validation complete!'));
+  } catch (error) {
+    log.error(pc.red(error.message));
+    if (error.stack && !options.quiet) {
+      log.error(pc.gray(error.stack));
+    }
+    process.exit(1);
+  }
+}

package/src/core/config.js

@@ -1,9 +1,15 @@
 import pkg from "fs-extra";
-const { readFile, writeFile, ensureDir } = pkg;
+const { readFile, writeFile, ensureDir, pathExists } = pkg;
 import { join } from "path";
 import { generateThemeStyles } from "./colors.js";
 
-export async function generateConfig(projectDir, options) {
+/**
+ * Generate configuration for the project
+ * @param {string} projectDir - The scaffolded project directory
+ * @param {object} options - CLI options
+ * @param {object|null} frameworkConfig - Framework configuration (optional)
+ */
+export async function generateConfig(projectDir, options, frameworkConfig = null) {
   const {
     baseUrl,
     name,
@@ -68,27 +74,65 @@ export async function generateConfig(projectDir, options) {
     await writeFile(join(stylesDir, "generated-theme.css"), "/* No generated theme styles */", "utf-8");
   }
 
-  // Update astro.config.mjs with base URL and site URL
-  if ((baseUrl && baseUrl !== "/") || config.metadata?.url) {
+  // Update astro.config.mjs with base URL and site URL (only for Astro)
+  const frameworkName = frameworkConfig?.name || 'astro';
+
+  if (frameworkName === 'astro' && ((baseUrl && baseUrl !== "/") || config.metadata?.url)) {
     const astroConfigPath = join(projectDir, "astro.config.mjs");
-    let content = await readFile(astroConfigPath, "utf-8");
+    if (await pathExists(astroConfigPath)) {
+      let content = await readFile(astroConfigPath, "utf-8");
+
+      let injection = "export default defineConfig({\n";
+
+      if (baseUrl && baseUrl !== "/") {
+        injection += `  base: '${baseUrl}',\n`;
+      }
+
+      if (config.metadata?.url) {
+        injection += `  site: '${config.metadata.url}',\n`;
+      }
+
+      // Add base/site option to defineConfig
+      content = content.replace(
+        "export default defineConfig({",
+        injection
+      );
 
-    let injection = "export default defineConfig({\n";
-    
-    if (baseUrl && baseUrl !== "/") {
-      injection += `  base: '${baseUrl}',\n`;
+      await writeFile(astroConfigPath, content, "utf-8");
     }
-    
-    if (config.metadata?.url) {
-      injection += `  site: '${config.metadata.url}',\n`;
+  }
+
+  // Update vite.config.js for React/Vue frameworks
+  if (['react', 'vue'].includes(frameworkName) && baseUrl && baseUrl !== "/") {
+    const viteConfigPath = join(projectDir, "vite.config.js");
+    if (await pathExists(viteConfigPath)) {
+      let content = await readFile(viteConfigPath, "utf-8");
+
+      // Add base option to defineConfig
+      if (content.includes("defineConfig({")) {
+        content = content.replace(
+          "defineConfig({",
+          `defineConfig({\n  base: '${baseUrl}',`
+        );
+        await writeFile(viteConfigPath, content, "utf-8");
+      }
     }
+  }
 
-    // Add base/site option to defineConfig
-    content = content.replace(
-      "export default defineConfig({",
-      injection
-    );
+  // Update next.config.js for Next.js
+  if (frameworkName === 'next' && baseUrl && baseUrl !== "/") {
+    const nextConfigPath = join(projectDir, "next.config.js");
+    if (await pathExists(nextConfigPath)) {
+      let content = await readFile(nextConfigPath, "utf-8");
 
-    await writeFile(astroConfigPath, content, "utf-8");
+      // Add basePath to Next.js config
+      if (!content.includes("basePath")) {
+        content = content.replace(
+          "module.exports = {",
+          `module.exports = {\n  basePath: '${baseUrl}',`
+        );
+        await writeFile(nextConfigPath, content, "utf-8");
+      }
+    }
   }
 }