@litodocs/cli 0.6.0 → 1.0.0

package/src/commands/build.js

@@ -5,10 +5,10 @@ import pc from 'picocolors';
 import { scaffoldProject, cleanupProject } from '../core/scaffold.js';
 import { syncDocs } from '../core/sync.js';
 import { generateConfig } from '../core/config.js';
-import { runAstroBuild } from '../core/astro.js';
 import { syncDocsConfig } from '../core/config-sync.js';
 import { copyOutput } from '../core/output.js';
 import { getTemplatePath } from '../core/template-fetcher.js';
+import { detectFramework, runFrameworkBuild, getOutputDir, needsSearchIndex } from '../core/framework-runner.js';
 
 export async function buildCommand(options) {
   try {
@@ -29,28 +29,33 @@ export async function buildCommand(options) {
     const templatePath = await getTemplatePath(options.template, options.refresh);
     s.stop(templatePath ? `Using template: ${pc.cyan(templatePath)}` : 'Using bundled template');
 
-    // Step 1: Scaffold temporary Astro project
-    s.start('Setting up Astro project...');
+    // Step 1: Scaffold temporary project
+    s.start('Setting up project...');
     const projectDir = await scaffoldProject(templatePath);
-    s.stop('Astro project scaffolded');
+    s.stop('Project scaffolded');
+
+    // Step 1.5: Detect framework
+    s.start('Detecting framework...');
+    const frameworkConfig = await detectFramework(projectDir);
+    s.stop(`Using framework: ${pc.cyan(frameworkConfig.name)}`);
 
     // Step 2: Prepare project (Install dependencies, Sync docs, Generate navigation)
     const { installDependencies, runBinary } = await import('../core/package-manager.js');
     s.start('Preparing project (installing dependencies, syncing files)...');
-    
+
     const userConfigPath = resolve(options.input, 'docs-config.json');
 
     await Promise.all([
       installDependencies(projectDir, { silent: true }),
-      syncDocs(inputPath, projectDir),
+      syncDocs(inputPath, projectDir, frameworkConfig),
       syncDocsConfig(projectDir, inputPath, userConfigPath)
     ]);
 
     s.stop('Project prepared (dependencies installed, docs synced, navigation generated)');
 
-    // Step 4: Generate config
-    s.start('Generating Astro configuration...');
-    await generateConfig(projectDir, options);
+    // Step 4: Generate config (framework-aware)
+    s.start(`Generating ${frameworkConfig.name} configuration...`);
+    await generateConfig(projectDir, options, frameworkConfig);
     s.stop('Configuration generated');
 
     // Step 4.5: Configure for provider
@@ -61,20 +66,24 @@ export async function buildCommand(options) {
       s.stop(`Configured for ${options.provider}`);
     }
 
-    // Step 5: Build with Astro
-    s.start('Building site with Astro...');
-    await runAstroBuild(projectDir);
+    // Step 5: Build with framework
+    s.start(`Building site with ${frameworkConfig.name}...`);
+    await runFrameworkBuild(projectDir, frameworkConfig);
     s.stop('Site built successfully');
 
-    // Step 5.5: Generate Pagefind search index
-    s.start('Generating search index...');
-    await runBinary(projectDir, 'pagefind', ['--site', 'dist']);
-    s.stop('Search index generated');
+    // Step 5.5: Generate Pagefind search index (only for static frameworks)
+    if (needsSearchIndex(frameworkConfig)) {
+      const outputDir = getOutputDir(frameworkConfig);
+      s.start('Generating search index...');
+      await runBinary(projectDir, 'pagefind', ['--site', outputDir]);
+      s.stop('Search index generated');
+    }
 
     // Step 6: Copy output
     const outputPath = resolve(options.output);
+    const frameworkOutputDir = getOutputDir(frameworkConfig);
     s.start(`Copying output to ${pc.cyan(outputPath)}...`);
-    await copyOutput(projectDir, outputPath);
+    await copyOutput(projectDir, outputPath, frameworkOutputDir);
     s.stop('Output copied');
 
     // Cleanup temp directory

package/src/commands/dev.js

@@ -6,9 +6,9 @@ import chokidar from 'chokidar';
 import { scaffoldProject, cleanupProject } from '../core/scaffold.js';
 import { syncDocs } from '../core/sync.js';
 import { generateConfig } from '../core/config.js';
-import { runAstroDev } from '../core/astro.js';
 import { syncDocsConfig } from '../core/config-sync.js';
 import { getTemplatePath } from '../core/template-fetcher.js';
+import { detectFramework, runFrameworkDev } from '../core/framework-runner.js';
 
 export async function devCommand(options) {
   try {
@@ -29,10 +29,15 @@ export async function devCommand(options) {
     const templatePath = await getTemplatePath(options.template, options.refresh);
     s.stop(templatePath ? `Using template: ${pc.cyan(templatePath)}` : 'Using bundled template');
 
-    // Step 1: Scaffold temporary Astro project
-    s.start('Setting up Astro project...');
+    // Step 1: Scaffold temporary project
+    s.start('Setting up project...');
     const projectDir = await scaffoldProject(templatePath);
-    s.stop('Astro project scaffolded');
+    s.stop('Project scaffolded');
+
+    // Step 1.5: Detect framework
+    s.start('Detecting framework...');
+    const frameworkConfig = await detectFramework(projectDir);
+    s.stop(`Using framework: ${pc.cyan(frameworkConfig.name)}`);
 
     // Register cleanup handlers
     const cleanup = async () => {
@@ -52,15 +57,15 @@ export async function devCommand(options) {
 
     await Promise.all([
       installDependencies(projectDir, { silent: true }),
-      syncDocs(inputPath, projectDir),
+      syncDocs(inputPath, projectDir, frameworkConfig),
       syncDocsConfig(projectDir, inputPath, userConfigPath)
     ]);
 
     s.stop('Project prepared (dependencies installed, docs synced, navigation generated)');
 
-    // Step 4: Generate config
-    s.start('Generating Astro configuration...');
-    await generateConfig(projectDir, options);
+    // Step 4: Generate config (framework-aware)
+    s.start(`Generating ${frameworkConfig.name} configuration...`);
+    await generateConfig(projectDir, options, frameworkConfig);
     s.stop('Configuration generated');
 
     // Step 4: Setup file watcher with debouncing
@@ -82,7 +87,7 @@ export async function devCommand(options) {
 
         try {
           await Promise.all([
-            syncDocs(inputPath, projectDir),
+            syncDocs(inputPath, projectDir, frameworkConfig),
             syncDocsConfig(projectDir, inputPath, userConfigPath)
           ]);
           log.success('Documentation and config re-synced');
@@ -115,9 +120,9 @@ export async function devCommand(options) {
       debouncedSync();
     });
 
-    // Step 5: Start Astro dev server
-    note(`Starting Astro dev server at http://localhost:${options.port}`, 'Dev Server');
-    await runAstroDev(projectDir, options.port);
+    // Step 5: Start framework dev server
+    note(`Starting ${frameworkConfig.name} dev server at http://localhost:${options.port}`, 'Dev Server');
+    await runFrameworkDev(projectDir, frameworkConfig, options.port);
 
   } catch (error) {
     if (isCancel(error)) {

package/src/commands/doctor.js

@@ -0,0 +1,311 @@
+import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
+import { resolve, join, extname } from 'path';
+import { intro, outro, log, spinner } from '@clack/prompts';
+import pc from 'picocolors';
+import { validateConfig } from '../core/config-validator.js';
+import { TEMPLATE_REGISTRY } from '../core/template-registry.js';
+
+/**
+ * Check result types
+ */
+const CHECK_PASS = 'pass';
+const CHECK_WARN = 'warn';
+const CHECK_FAIL = 'fail';
+
+/**
+ * Doctor command - Diagnose common issues
+ */
+export async function doctorCommand(options) {
+  try {
+    const inputPath = options.input ? resolve(options.input) : process.cwd();
+
+    console.clear();
+    intro(pc.inverse(pc.cyan(' Lito - Doctor ')));
+
+    log.message(pc.dim(`Checking: ${inputPath}`));
+    log.message('');
+
+    const checks = [];
+
+    // Check 1: Directory exists
+    checks.push(await checkDirectoryExists(inputPath));
+
+    // Check 2: docs-config.json exists
+    checks.push(await checkConfigExists(inputPath));
+
+    // Check 3: Config is valid JSON
+    const configCheck = await checkConfigValid(inputPath);
+    checks.push(configCheck);
+
+    // Check 4: Config passes validation
+    if (configCheck.status === CHECK_PASS) {
+      checks.push(await checkConfigSchema(inputPath));
+    }
+
+    // Check 5: Content files exist
+    checks.push(await checkContentFiles(inputPath));
+
+    // Check 6: Check for common issues
+    checks.push(await checkCommonIssues(inputPath));
+
+    // Check 7: Template cache
+    checks.push(await checkTemplateCache());
+
+    // Check 8: Node.js version
+    checks.push(await checkNodeVersion());
+
+    // Print results
+    log.message('');
+    log.message(pc.bold('Diagnostic Results:'));
+    log.message('');
+
+    let hasErrors = false;
+    let hasWarnings = false;
+
+    for (const check of checks) {
+      const icon =
+        check.status === CHECK_PASS
+          ? pc.green('✓')
+          : check.status === CHECK_WARN
+          ? pc.yellow('!')
+          : pc.red('✗');
+
+      log.message(`  ${icon} ${check.name}`);
+
+      if (check.message) {
+        log.message(`    ${pc.dim(check.message)}`);
+      }
+
+      if (check.status === CHECK_FAIL) hasErrors = true;
+      if (check.status === CHECK_WARN) hasWarnings = true;
+    }
+
+    log.message('');
+
+    // Summary
+    if (hasErrors) {
+      log.error(pc.red('Some checks failed. Please fix the issues above.'));
+      process.exit(1);
+    } else if (hasWarnings) {
+      log.warn(pc.yellow('Some warnings found. Your project should still work.'));
+      outro(pc.yellow('Doctor completed with warnings'));
+    } else {
+      log.success(pc.green('All checks passed!'));
+      outro(pc.green('Your project looks healthy! 🎉'));
+    }
+  } catch (error) {
+    log.error(pc.red(error.message));
+    process.exit(1);
+  }
+}
+
+async function checkDirectoryExists(inputPath) {
+  if (!existsSync(inputPath)) {
+    return {
+      name: 'Directory exists',
+      status: CHECK_FAIL,
+      message: `Directory not found: ${inputPath}`,
+    };
+  }
+
+  const stat = statSync(inputPath);
+  if (!stat.isDirectory()) {
+    return {
+      name: 'Directory exists',
+      status: CHECK_FAIL,
+      message: `Path is not a directory: ${inputPath}`,
+    };
+  }
+
+  return {
+    name: 'Directory exists',
+    status: CHECK_PASS,
+  };
+}
+
+async function checkConfigExists(inputPath) {
+  const configPath = join(inputPath, 'docs-config.json');
+
+  if (!existsSync(configPath)) {
+    return {
+      name: 'docs-config.json exists',
+      status: CHECK_FAIL,
+      message: `Run 'lito init' to create a configuration file`,
+    };
+  }
+
+  return {
+    name: 'docs-config.json exists',
+    status: CHECK_PASS,
+  };
+}
+
+async function checkConfigValid(inputPath) {
+  const configPath = join(inputPath, 'docs-config.json');
+
+  if (!existsSync(configPath)) {
+    return {
+      name: 'Config is valid JSON',
+      status: CHECK_WARN,
+      message: 'Skipped (no config file)',
+    };
+  }
+
+  try {
+    JSON.parse(readFileSync(configPath, 'utf-8'));
+    return {
+      name: 'Config is valid JSON',
+      status: CHECK_PASS,
+    };
+  } catch (e) {
+    return {
+      name: 'Config is valid JSON',
+      status: CHECK_FAIL,
+      message: e.message,
+    };
+  }
+}
+
+async function checkConfigSchema(inputPath) {
+  const configPath = join(inputPath, 'docs-config.json');
+
+  try {
+    const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+    const result = validateConfig(config, inputPath, { silent: true });
+
+    if (!result.valid) {
+      return {
+        name: 'Config passes validation',
+        status: CHECK_FAIL,
+        message: result.errors.map((e) => e.message).join('; '),
+      };
+    }
+
+    return {
+      name: 'Config passes validation',
+      status: CHECK_PASS,
+    };
+  } catch (e) {
+    return {
+      name: 'Config passes validation',
+      status: CHECK_WARN,
+      message: 'Could not validate',
+    };
+  }
+}
+
+async function checkContentFiles(inputPath) {
+  try {
+    const files = readdirSync(inputPath);
+    const contentFiles = files.filter((f) => {
+      const ext = extname(f).toLowerCase();
+      return ['.md', '.mdx'].includes(ext);
+    });
+
+    if (contentFiles.length === 0) {
+      return {
+        name: 'Content files exist',
+        status: CHECK_WARN,
+        message: 'No .md or .mdx files found in root directory',
+      };
+    }
+
+    return {
+      name: 'Content files exist',
+      status: CHECK_PASS,
+      message: `Found ${contentFiles.length} content file(s)`,
+    };
+  } catch (e) {
+    return {
+      name: 'Content files exist',
+      status: CHECK_WARN,
+      message: 'Could not read directory',
+    };
+  }
+}
+
+async function checkCommonIssues(inputPath) {
+  const issues = [];
+
+  // Check for node_modules in docs folder (shouldn't be there)
+  if (existsSync(join(inputPath, 'node_modules'))) {
+    issues.push('node_modules folder found in docs (should be removed)');
+  }
+
+  // Check for package.json in docs folder (might cause conflicts)
+  if (existsSync(join(inputPath, 'package.json'))) {
+    issues.push('package.json in docs folder (may cause conflicts)');
+  }
+
+  // Check for .git in docs folder
+  if (existsSync(join(inputPath, '.git'))) {
+    issues.push('.git folder in docs (unusual structure)');
+  }
+
+  if (issues.length > 0) {
+    return {
+      name: 'No common issues',
+      status: CHECK_WARN,
+      message: issues.join('; '),
+    };
+  }
+
+  return {
+    name: 'No common issues',
+    status: CHECK_PASS,
+  };
+}
+
+async function checkTemplateCache() {
+  const cacheDir = join(process.env.HOME || '~', '.lito', 'templates');
+
+  if (!existsSync(cacheDir)) {
+    return {
+      name: 'Template cache',
+      status: CHECK_PASS,
+      message: 'No cached templates',
+    };
+  }
+
+  try {
+    const cached = readdirSync(cacheDir);
+    return {
+      name: 'Template cache',
+      status: CHECK_PASS,
+      message: `${cached.length} template(s) cached`,
+    };
+  } catch (e) {
+    return {
+      name: 'Template cache',
+      status: CHECK_WARN,
+      message: 'Could not read cache directory',
+    };
+  }
+}
+
+async function checkNodeVersion() {
+  const version = process.version;
+  const major = parseInt(version.slice(1).split('.')[0], 10);
+
+  if (major < 18) {
+    return {
+      name: 'Node.js version',
+      status: CHECK_FAIL,
+      message: `Node.js 18+ required (found ${version})`,
+    };
+  }
+
+  if (major < 20) {
+    return {
+      name: 'Node.js version',
+      status: CHECK_WARN,
+      message: `Node.js 20+ recommended (found ${version})`,
+    };
+  }
+
+  return {
+    name: 'Node.js version',
+    status: CHECK_PASS,
+    message: version,
+  };
+}

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