@litodocs/cli 0.6.0 → 0.7.0

package/src/commands/info.js

@@ -0,0 +1,192 @@
+import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
+import { resolve, join, extname } from 'path';
+import { intro, outro, log } from '@clack/prompts';
+import pc from 'picocolors';
+import { TEMPLATE_REGISTRY } from '../core/template-registry.js';
+import { getCoreConfigKeys, getExtensionKeys, isPortableConfig } from '../core/config-validator.js';
+
+/**
+ * Info command - Show project information
+ */
+export async function infoCommand(options) {
+  try {
+    const inputPath = options.input ? resolve(options.input) : process.cwd();
+    const configPath = join(inputPath, 'docs-config.json');
+
+    console.clear();
+    intro(pc.inverse(pc.cyan(' Lito - Project Info ')));
+
+    log.message(pc.dim(`Path: ${inputPath}`));
+    log.message('');
+
+    // Check if config exists
+    if (!existsSync(configPath)) {
+      log.warn('No docs-config.json found in this directory.');
+      log.message('');
+      log.message(`Run ${pc.cyan('lito init')} to create a new project.`);
+      outro('');
+      return;
+    }
+
+    // Parse config
+    let config;
+    try {
+      config = JSON.parse(readFileSync(configPath, 'utf-8'));
+    } catch (e) {
+      log.error(`Failed to parse docs-config.json: ${e.message}`);
+      process.exit(1);
+    }
+
+    // Project info
+    log.message(pc.bold('📦 Project'));
+    log.message(`  ${pc.cyan('Name:')} ${config.metadata?.name || pc.dim('(not set)')}`);
+    if (config.metadata?.description) {
+      log.message(`  ${pc.cyan('Description:')} ${config.metadata.description}`);
+    }
+    log.message('');
+
+    // Content stats
+    const stats = getContentStats(inputPath);
+    log.message(pc.bold('📄 Content'));
+    log.message(`  ${pc.cyan('Markdown files:')} ${stats.mdFiles}`);
+    log.message(`  ${pc.cyan('MDX files:')} ${stats.mdxFiles}`);
+    log.message(`  ${pc.cyan('Total pages:')} ${stats.mdFiles + stats.mdxFiles}`);
+    if (stats.directories > 0) {
+      log.message(`  ${pc.cyan('Subdirectories:')} ${stats.directories}`);
+    }
+    log.message('');
+
+    // Navigation
+    if (config.navigation) {
+      log.message(pc.bold('🧭 Navigation'));
+      const sidebarGroups = config.navigation.sidebar?.length || 0;
+      const sidebarItems = config.navigation.sidebar?.reduce(
+        (acc, g) => acc + (g.items?.length || 0),
+        0
+      ) || 0;
+      const navbarLinks = config.navigation.navbar?.links?.length || 0;
+
+      log.message(`  ${pc.cyan('Sidebar groups:')} ${sidebarGroups}`);
+      log.message(`  ${pc.cyan('Sidebar items:')} ${sidebarItems}`);
+      log.message(`  ${pc.cyan('Navbar links:')} ${navbarLinks}`);
+      log.message('');
+    }
+
+    // Features
+    log.message(pc.bold('⚡ Features'));
+    const features = [
+      { name: 'Search', enabled: config.search?.enabled },
+      { name: 'i18n', enabled: config.i18n?.enabled },
+      { name: 'Versioning', enabled: config.versioning?.enabled },
+      { name: 'Dark Mode', enabled: config.theme?.darkMode !== false },
+    ];
+
+    for (const feature of features) {
+      const icon = feature.enabled ? pc.green('✓') : pc.dim('○');
+      log.message(`  ${icon} ${feature.name}`);
+    }
+    log.message('');
+
+    // Branding
+    if (config.branding) {
+      log.message(pc.bold('🎨 Branding'));
+      if (config.branding.logo) {
+        const logo = config.branding.logo;
+        if (typeof logo === 'string') {
+          log.message(`  ${pc.cyan('Logo:')} ${logo}`);
+        } else if (logo.light || logo.dark) {
+          log.message(`  ${pc.cyan('Logo:')} ${logo.light || logo.dark} ${logo.light && logo.dark ? '(light/dark)' : ''}`);
+        }
+      }
+      if (config.branding.favicon) {
+        log.message(`  ${pc.cyan('Favicon:')} ${config.branding.favicon}`);
+      }
+      if (config.branding.colors?.primary) {
+        log.message(`  ${pc.cyan('Primary color:')} ${config.branding.colors.primary}`);
+      }
+      if (config.branding.colors?.accent) {
+        log.message(`  ${pc.cyan('Accent color:')} ${config.branding.colors.accent}`);
+      }
+      log.message('');
+    }
+
+    // Config compatibility
+    log.message(pc.bold('🔧 Configuration'));
+    const portable = isPortableConfig(config);
+    const usedCoreKeys = getCoreConfigKeys().filter((k) => k in config);
+    const usedExtKeys = getExtensionKeys().filter((k) => k in config);
+
+    log.message(`  ${pc.cyan('Core keys:')} ${usedCoreKeys.join(', ') || 'none'}`);
+    if (usedExtKeys.length > 0) {
+      log.message(`  ${pc.cyan('Extension keys:')} ${usedExtKeys.join(', ')}`);
+    }
+    log.message(
+      `  ${pc.cyan('Portable:')} ${portable ? pc.green('Yes') : pc.yellow('No (uses extensions)')}`
+    );
+    log.message('');
+
+    // Available templates
+    log.message(pc.bold('📋 Available Templates'));
+    for (const [name, source] of Object.entries(TEMPLATE_REGISTRY)) {
+      log.message(`  ${pc.cyan(name)}: ${pc.dim(source)}`);
+    }
+    log.message('');
+
+    // CLI info
+    log.message(pc.bold('🔧 Environment'));
+    log.message(`  ${pc.cyan('Node.js:')} ${process.version}`);
+    log.message(`  ${pc.cyan('Platform:')} ${process.platform}`);
+
+    const cacheDir = join(process.env.HOME || '~', '.lito', 'templates');
+    if (existsSync(cacheDir)) {
+      const cached = readdirSync(cacheDir).length;
+      log.message(`  ${pc.cyan('Cached templates:')} ${cached}`);
+    }
+
+    outro('');
+  } catch (error) {
+    log.error(pc.red(error.message));
+    process.exit(1);
+  }
+}
+
+/**
+ * Get content statistics for a docs directory
+ */
+function getContentStats(inputPath) {
+  const stats = {
+    mdFiles: 0,
+    mdxFiles: 0,
+    directories: 0,
+  };
+
+  function scan(dir) {
+    try {
+      const entries = readdirSync(dir);
+
+      for (const entry of entries) {
+        // Skip special directories
+        if (entry.startsWith('_') || entry.startsWith('.') || entry === 'node_modules') {
+          continue;
+        }
+
+        const fullPath = join(dir, entry);
+        const stat = statSync(fullPath);
+
+        if (stat.isDirectory()) {
+          stats.directories++;
+          scan(fullPath);
+        } else if (stat.isFile()) {
+          const ext = extname(entry).toLowerCase();
+          if (ext === '.md') stats.mdFiles++;
+          if (ext === '.mdx') stats.mdxFiles++;
+        }
+      }
+    } catch (e) {
+      // Ignore errors
+    }
+  }
+
+  scan(inputPath);
+  return stats;
+}

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);
+  }
+}