@litodocs/cli 0.5.0

package/src/commands/eject.js

@@ -0,0 +1,89 @@
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+import { intro, outro, spinner, log, note, isCancel, cancel } from '@clack/prompts';
+import pc from 'picocolors';
+import fs from 'fs-extra';
+import { scaffoldProject, cleanupProject } from '../core/scaffold.js';
+import { syncDocs } from '../core/sync.js';
+import { generateConfig } from '../core/config.js';
+import { syncDocsConfig } from '../core/config-sync.js';
+import { getTemplatePath } from '../core/template-fetcher.js';
+
+export async function ejectCommand(options) {
+  try {
+    // Validate input path
+    const inputPath = resolve(options.input);
+    if (!existsSync(inputPath)) {
+      log.error(`Input path does not exist: ${pc.cyan(inputPath)}`);
+      process.exit(1);
+    }
+
+    const outputPath = resolve(options.output);
+    if (existsSync(outputPath)) {
+      log.error(`Output path already exists: ${pc.cyan(outputPath)}`);
+      log.warning('Please provide a path to a non-existent directory to avoid overwriting files.');
+      process.exit(1);
+    }
+
+    console.clear();
+    intro(pc.inverse(pc.cyan(' Lito - Eject ')));
+
+    const s = spinner();
+
+    // Step 0: Resolve template
+    s.start('Resolving template...');
+    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('Scaffolding Astro project...');
+    const projectDir = await scaffoldProject(templatePath);
+    s.stop('Astro project scaffolded');
+
+    // Step 2: Sync docs to Astro
+    s.start('Syncing documentation files...');
+    await syncDocs(inputPath, projectDir);
+    s.stop('Documentation synced');
+
+    // Step 3: Sync docs config (auto-generate navigation)
+    s.start('Generating navigation...');
+    const userConfigPath = resolve(options.input, 'docs-config.json');
+    await syncDocsConfig(projectDir, inputPath, userConfigPath);
+    s.stop('Navigation generated');
+
+    // Step 4: Generate config
+    s.start('Generating Astro configuration...');
+    await generateConfig(projectDir, options);
+    s.stop('Configuration generated');
+
+    // Step 5: Copy entire project to output
+    s.start('Exporting project source code...');
+    await fs.copy(projectDir, outputPath);
+    s.stop(`Project exported to ${pc.cyan(outputPath)}`);
+
+    // Clean up temp directory
+    s.start('Cleaning up...');
+    await cleanupProject();
+    s.stop('Cleanup complete');
+
+    // Step 6: Final instructions
+    const { getInstallInstruction, getRunInstruction } = await import('../core/package-manager.js');
+    const installCmd = await getInstallInstruction();
+    const devCmd = await getRunInstruction('dev');
+
+    note(`${pc.cyan(`cd ${options.output}`)}\n${pc.cyan(installCmd)}\n${pc.cyan(devCmd)}`, 'To get started');
+
+    outro(pc.green('Project ejected successfully!'));
+
+  } catch (error) {
+    if (isCancel(error)) {
+      cancel('Operation cancelled.');
+      process.exit(0);
+    }
+    log.error(pc.red('Eject failed: ' + error.message));
+    if (error.stack) {
+      log.error(pc.gray(error.stack));
+    }
+    process.exit(1);
+  }
+}

package/src/commands/template.js

@@ -0,0 +1,80 @@
+import { intro, outro, spinner, log, note } from '@clack/prompts';
+import pc from 'picocolors';
+import { listCachedTemplates, clearTemplateCache } from '../core/template-fetcher.js';
+import { getRegistryNames, getRegistryInfo } from '../core/template-registry.js';
+
+/**
+ * List available templates
+ */
+export async function templateListCommand() {
+    intro(pc.inverse(pc.cyan(' Lito - Templates ')));
+
+    // Show registry templates
+    const names = getRegistryNames();
+
+    log.info(pc.bold('Available Templates:'));
+    console.log('');
+
+    for (const name of names) {
+        const info = getRegistryInfo(name);
+        console.log(`  ${pc.blue('●')} ${pc.bold(name)} ${pc.dim(`→ ${info.source}`)}`);
+    }
+
+    console.log('');
+    log.info(pc.dim('You can also use GitHub URLs directly:'));
+    console.log(pc.dim('  lito dev -i . --template github:owner/repo'));
+    console.log(pc.dim('  lito dev -i . --template github:owner/repo#v1.0.0'));
+    console.log('');
+
+    // Show cached templates
+    const cached = await listCachedTemplates();
+    if (cached.length > 0) {
+        log.info(pc.bold('Cached Templates:'));
+        console.log('');
+        for (const t of cached) {
+            const age = Math.round((Date.now() - t.cachedAt) / (1000 * 60));
+            console.log(`  ${pc.yellow('●')} ${t.owner}/${t.repo}#${t.ref} ${pc.dim(`(cached ${age}m ago)`)}`);
+        }
+        console.log('');
+    }
+
+    outro(pc.dim('Use --template to select a template'));
+}
+
+/**
+ * Manage template cache
+ */
+export async function templateCacheCommand(options) {
+    intro(pc.inverse(pc.cyan(' Lito - Template Cache ')));
+
+    if (options.clear) {
+        const s = spinner();
+        s.start('Clearing template cache...');
+        await clearTemplateCache();
+        s.stop('Template cache cleared');
+        outro(pc.green('Done!'));
+        return;
+    }
+
+    // Show cache info
+    const cached = await listCachedTemplates();
+
+    if (cached.length === 0) {
+        log.info('No templates cached.');
+        outro('');
+        return;
+    }
+
+    log.info(pc.bold(`${cached.length} template(s) cached:`));
+    console.log('');
+
+    for (const t of cached) {
+        const age = Math.round((Date.now() - t.cachedAt) / (1000 * 60 * 60));
+        console.log(`  ${pc.cyan(t.owner)}/${pc.cyan(t.repo)}#${pc.yellow(t.ref)}`);
+        console.log(`    ${pc.dim(`Cached ${age}h ago`)}`);
+    }
+
+    console.log('');
+    note('lito template cache --clear', 'To clear cache');
+    outro('');
+}

package/src/core/astro.js

@@ -0,0 +1,9 @@
+import { runBinary } from './package-manager.js';
+
+export async function runAstroBuild(projectDir) {
+  await runBinary(projectDir, 'astro', ['build']);
+}
+
+export async function runAstroDev(projectDir, port = '4321') {
+  await runBinary(projectDir, 'astro', ['dev', '--port', port]);
+}

package/src/core/colors.js

@@ -0,0 +1,142 @@
+
+
+function hexToRgb(hex) {
+  const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+  if (!result) return { r: 0, g: 0, b: 0 };
+  return {
+    r: parseInt(result[1], 16) / 255,
+    g: parseInt(result[2], 16) / 255,
+    b: parseInt(result[3], 16) / 255,
+  };
+}
+
+function linearRgbToOklab(rgb) {
+  const toLinear = (c) =>
+    c <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+  const r = toLinear(rgb.r);
+  const g = toLinear(rgb.g);
+  const b = toLinear(rgb.b);
+  const l = Math.cbrt(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b);
+  const m = Math.cbrt(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b);
+  const s = Math.cbrt(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b);
+  return {
+    L: 0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s,
+    a: 1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s,
+    b: 0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s,
+  };
+}
+
+function oklabToOklch(lab) {
+  const c = Math.sqrt(lab.a * lab.a + lab.b * lab.b);
+  let h = (Math.atan2(lab.b, lab.a) * 180) / Math.PI;
+  if (h < 0) h += 360;
+  return { l: lab.L, c: c, h: h };
+}
+
+function hexToOklch(hex) {
+  return oklabToOklch(linearRgbToOklab(hexToRgb(hex)));
+}
+
+function formatOklch(oklch, alpha) {
+  const l = oklch.l.toFixed(3);
+  const c = oklch.c.toFixed(3);
+  const h = Math.round(oklch.h);
+  return alpha !== undefined
+    ? `oklch(${l} ${c} ${h} / ${alpha})`
+    : `oklch(${l} ${c} ${h})`;
+}
+
+function generatePalette(hex, prefix = 'primary') {
+  const base = hexToOklch(hex);
+  const shades = {
+    '50': 0.98, '100': 0.95, '200': 0.90, '300': 0.82, '400': 0.70,
+    '500': 0.55, '600': 0.48, '700': 0.40, '800': 0.32, '900': 0.24, '950': 0.18,
+  };
+  const palette = {};
+  for (const [shade, lightness] of Object.entries(shades)) {
+    let chroma = base.c;
+    if (lightness > 0.85 || lightness < 0.25) chroma = base.c * 0.3;
+    else if (lightness > 0.75 || lightness < 0.35) chroma = base.c * 0.6;
+    else if (lightness > 0.65 || lightness < 0.45) chroma = base.c * 0.85;
+    palette[`--${prefix}-${shade}`] = formatOklch({ l: lightness, c: Math.min(chroma, 0.15), h: base.h });
+  }
+  return palette;
+}
+
+function generateDarkPalette(hex, prefix = 'primary') {
+  const base = hexToOklch(hex);
+  const shades = {
+    '50': 0.20, '100': 0.25, '200': 0.32, '300': 0.42, '400': 0.55,
+    '500': 0.65, '600': 0.72, '700': 0.80, '800': 0.88, '900': 0.94, '950': 0.97,
+  };
+  const palette = {};
+  for (const [shade, lightness] of Object.entries(shades)) {
+    let chroma = base.c;
+    if (lightness > 0.85 || lightness < 0.25) chroma = base.c * 0.3;
+    else if (lightness > 0.75 || lightness < 0.35) chroma = base.c * 0.6;
+    else if (lightness > 0.65 || lightness < 0.45) chroma = base.c * 0.85;
+    palette[`--${prefix}-${shade}`] = formatOklch({ l: lightness, c: Math.min(chroma, 0.15), h: base.h });
+  }
+  return palette;
+}
+
+function generateGrayPalette(tintHex) {
+  const tint = tintHex ? hexToOklch(tintHex) : { l: 0, c: 0, h: 0 };
+  const hue = tint.h;
+  const lightShades = {
+    '50': { l: 0.99, c: 0.002 }, '100': { l: 0.97, c: 0.003 }, '200': { l: 0.93, c: 0.005 },
+    '300': { l: 0.87, c: 0.008 }, '400': { l: 0.70, c: 0.010 }, '500': { l: 0.55, c: 0.012 },
+    '600': { l: 0.45, c: 0.010 }, '700': { l: 0.35, c: 0.008 }, '800': { l: 0.25, c: 0.005 },
+    '900': { l: 0.18, c: 0.003 }, '950': { l: 0.12, c: 0.002 },
+  };
+  const darkShades = {
+    '50': { l: 0.13, c: 0.003 }, '100': { l: 0.17, c: 0.005 }, '200': { l: 0.22, c: 0.008 },
+    '300': { l: 0.30, c: 0.010 }, '400': { l: 0.42, c: 0.012 }, '500': { l: 0.55, c: 0.010 },
+    '600': { l: 0.65, c: 0.008 }, '700': { l: 0.75, c: 0.005 }, '800': { l: 0.85, c: 0.003 },
+    '900': { l: 0.92, c: 0.002 }, '950': { l: 0.97, c: 0.001 },
+  };
+  const light = {};
+  const dark = {};
+  for (const [shade, values] of Object.entries(lightShades)) {
+    light[`--gray-${shade}`] = formatOklch({ l: values.l, c: values.c, h: hue });
+  }
+  for (const [shade, values] of Object.entries(darkShades)) {
+    dark[`--gray-${shade}`] = formatOklch({ l: values.l, c: values.c, h: hue });
+  }
+  return { light, dark };
+}
+
+export function generateThemeStyles(colors) {
+  if (!colors || !colors.primary) return '';
+  const primaryPalette = generatePalette(colors.primary, 'primary');
+  const primaryDarkPalette = generateDarkPalette(colors.primary, 'primary');
+  const grayPalettes = generateGrayPalette(colors.primary);
+
+  let lightVars = Object.entries(primaryPalette).map(([k, v]) => `${k}: ${v};`).join('\n    ');
+  lightVars += '\n    ' + Object.entries(grayPalettes.light).map(([k, v]) => `${k}: ${v};`).join('\n    ');
+
+  let darkVars = Object.entries(primaryDarkPalette).map(([k, v]) => `${k}: ${v};`).join('\n    ');
+  darkVars += '\n    ' + Object.entries(grayPalettes.dark).map(([k, v]) => `${k}: ${v};`).join('\n    ');
+
+  const baseOklch = hexToOklch(colors.primary);
+  const shadowVars = `
+    --shadow-primary-sm: 0 2px 8px -2px ${formatOklch({ l: 0.55, c: 0.13, h: baseOklch.h }, 0.20)};
+    --shadow-primary: 0 4px 16px -4px ${formatOklch({ l: 0.55, c: 0.13, h: baseOklch.h }, 0.25)};
+    --shadow-primary-lg: 0 12px 32px -8px ${formatOklch({ l: 0.55, c: 0.13, h: baseOklch.h }, 0.30)};`;
+  const darkShadowVars = `
+    --shadow-primary-sm: 0 2px 8px -2px ${formatOklch({ l: 0.65, c: 0.13, h: baseOklch.h }, 0.30)};
+    --shadow-primary: 0 4px 16px -4px ${formatOklch({ l: 0.65, c: 0.13, h: baseOklch.h }, 0.40)};
+    --shadow-primary-lg: 0 12px 32px -8px ${formatOklch({ l: 0.65, c: 0.13, h: baseOklch.h }, 0.50)};`;
+
+  return `
+/* Generated Theme Styles */
+:root {
+    ${lightVars}
+    ${shadowVars}
+}
+
+.dark {
+    ${darkVars}
+    ${darkShadowVars}
+}`;
+}

package/src/core/config-sync.js

@@ -0,0 +1,117 @@
+import pkg from 'fs-extra';
+const { readFile, writeFile, pathExists } = pkg;
+import { join } from 'path';
+import { readdir } from 'fs/promises';
+
+/**
+ * Auto-generates navigation structure from docs folder
+ */
+export async function generateNavigationFromDocs(docsPath) {
+  const sidebar = [];
+
+  try {
+    const entries = await readdir(docsPath, { withFileTypes: true });
+
+    // Group files by directory
+    const groups = new Map();
+
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const dirName = entry.name;
+        const dirPath = join(docsPath, dirName);
+        const files = await readdir(dirPath);
+
+        const items = files
+          .filter(f => f.endsWith('.md') || f.endsWith('.mdx'))
+          .map(f => ({
+            label: formatLabel(f.replace(/\.(md|mdx)$/, '')),
+            slug: `${dirName}/${f.replace(/\.(md|mdx)$/, '')}`,
+          }))
+          .sort((a, b) => a.label.localeCompare(b.label));
+
+        if (items.length > 0) {
+          groups.set(dirName, {
+            label: formatLabel(dirName),
+            items,
+          });
+        }
+      }
+    }
+
+    // Add root-level files
+    const rootFiles = entries
+      .filter(e => e.isFile() && (e.name.endsWith('.md') || e.name.endsWith('.mdx')) && e.name !== 'index.md')
+      .map(e => ({
+        label: formatLabel(e.name.replace(/\.(md|mdx)$/, '')),
+        slug: e.name.replace(/\.(md|mdx)$/, ''),
+      }))
+      .sort((a, b) => a.label.localeCompare(b.label));
+
+    if (rootFiles.length > 0) {
+      sidebar.push({
+        label: 'Getting Started',
+        icon: 'lucide:rocket',
+        items: rootFiles,
+      });
+    }
+
+    // Add directory groups sorted alphabetically
+    const sortedGroups = Array.from(groups.values()).sort((a, b) => a.label.localeCompare(b.label));
+    for (const group of sortedGroups) {
+      sidebar.push(group);
+    }
+
+  } catch (error) {
+    console.warn('Could not auto-generate navigation:', error.message);
+  }
+
+  return sidebar;
+}
+
+/**
+ * Merges user config with auto-generated navigation
+ */
+export async function syncDocsConfig(projectDir, docsPath, userConfigPath) {
+  const configPath = join(projectDir, 'docs-config.json');
+
+  // Read base config from template
+  let config = JSON.parse(await readFile(configPath, 'utf-8'));
+
+  // If user has a custom config, merge it
+  if (userConfigPath && await pathExists(userConfigPath)) {
+    const userConfig = JSON.parse(await readFile(userConfigPath, 'utf-8'));
+    config = deepMerge(config, userConfig);
+  }
+
+  // Auto-generate navigation if not provided
+  if (!config.navigation?.sidebar || config.navigation.sidebar.length === 0) {
+    config.navigation.sidebar = await generateNavigationFromDocs(docsPath);
+  }
+
+  // Write merged config
+  await writeFile(configPath, JSON.stringify(config, null, 2), 'utf-8');
+}
+
+function formatLabel(str) {
+  return str
+    .split('-')
+    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(' ');
+}
+
+function deepMerge(target, source) {
+  const output = { ...target };
+
+  for (const key in source) {
+    // Arrays should be replaced, not merged
+    if (Array.isArray(source[key])) {
+      output[key] = source[key];
+    } else if (source[key] instanceof Object && key in target && !Array.isArray(target[key])) {
+      output[key] = deepMerge(target[key], source[key]);
+    } else {
+      output[key] = source[key];
+    }
+  }
+
+  return output;
+}

package/src/core/config.js

@@ -0,0 +1,94 @@
+import pkg from "fs-extra";
+const { readFile, writeFile, ensureDir } = pkg;
+import { join } from "path";
+import { generateThemeStyles } from "./colors.js";
+
+export async function generateConfig(projectDir, options) {
+  const {
+    baseUrl,
+    name,
+    description,
+    primaryColor,
+    accentColor,
+    favicon,
+    logo,
+  } = options;
+
+  // Update docs-config.json with metadata and theme options
+  const configPath = join(projectDir, "docs-config.json");
+  let config = JSON.parse(await readFile(configPath, "utf-8"));
+
+  // Update metadata
+  if (name) {
+    config.metadata = config.metadata || {};
+    config.metadata.name = name;
+  }
+
+  if (description) {
+    config.metadata = config.metadata || {};
+    config.metadata.description = description;
+  }
+
+  // Update theme colors
+  if (primaryColor || accentColor) {
+    config.theme = config.theme || {};
+    config.branding = config.branding || {};
+    config.branding.colors = config.branding.colors || {};
+
+    if (primaryColor) {
+      config.theme.primaryColor = primaryColor;
+      config.branding.colors.primary = primaryColor;
+    }
+    if (accentColor) {
+      config.theme.accentColor = accentColor;
+      config.branding.colors.accent = accentColor;
+    }
+  }
+
+  // Update branding
+  if (favicon || logo) {
+    config.branding = config.branding || {};
+    if (favicon) config.branding.favicon = favicon;
+    if (logo) config.branding.logo = config.branding.logo || {};
+    if (logo) config.branding.logo.src = logo;
+  }
+
+  await writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
+
+  // Generate theme styles
+  if (config.branding?.colors?.primary) {
+    const themeStyles = generateThemeStyles(config.branding.colors);
+    const stylesDir = join(projectDir, "src", "styles");
+    await ensureDir(stylesDir);
+    await writeFile(join(stylesDir, "generated-theme.css"), themeStyles, "utf-8");
+  } else {
+    // Write empty file to avoid import error
+    const stylesDir = join(projectDir, "src", "styles");
+    await ensureDir(stylesDir);
+    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) {
+    const astroConfigPath = join(projectDir, "astro.config.mjs");
+    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
+    );
+
+    await writeFile(astroConfigPath, content, "utf-8");
+  }
+}

package/src/core/output.js

@@ -0,0 +1,15 @@
+import pkg from 'fs-extra';
+const { copy, ensureDir } = pkg;
+import { join } from 'path';
+
+export async function copyOutput(projectDir, outputPath) {
+  const distPath = join(projectDir, 'dist');
+  
+  // Ensure output directory exists
+  await ensureDir(outputPath);
+  
+  // Copy built files to output
+  await copy(distPath, outputPath, {
+    overwrite: true,
+  });
+}

package/src/core/package-manager.js

@@ -0,0 +1,96 @@
+import { execa } from 'execa';
+
+let detectedManager = null;
+
+export async function getPackageManager() {
+    if (detectedManager) return detectedManager;
+
+    // Check for Bun first (fastest) - keeping preference for Bun as per user rules if available
+    try {
+        await execa('bun', ['--version']);
+        detectedManager = 'bun';
+        return 'bun';
+    } catch { }
+
+    // Check for pnpm
+    try {
+        await execa('pnpm', ['--version']);
+        detectedManager = 'pnpm';
+        return 'pnpm';
+    } catch { }
+
+    // Check for yarn
+    try {
+        await execa('yarn', ['--version']);
+        detectedManager = 'yarn';
+        return 'yarn';
+    } catch { }
+
+    // Default to npm
+    detectedManager = 'npm';
+    return 'npm';
+}
+
+export async function installDependencies(projectDir, { silent = true } = {}) {
+    const manager = await getPackageManager();
+
+    await execa(manager, ['install'], {
+        cwd: projectDir,
+        stdio: silent ? 'pipe' : 'inherit',
+        env: { ...process.env, CI: 'true' }, // Force non-interactive mode
+    });
+}
+
+export async function installPackage(projectDir, packageName, { dev = false, silent = true } = {}) {
+    const manager = await getPackageManager();
+    const args = manager === 'npm' ? ['install'] : ['add'];
+    
+    if (dev) {
+        args.push('-D');
+    }
+    
+    args.push(packageName);
+
+    await execa(manager, args, {
+        cwd: projectDir,
+        stdio: silent ? 'pipe' : 'inherit',
+    });
+}
+
+/**
+ * Runs a binary using the package manager (e.g. 'astro').
+ */
+export async function runBinary(projectDir, binary, args = []) {
+    const manager = await getPackageManager();
+
+    let cmd = manager;
+    let cmdArgs = [];
+
+    if (manager === 'npm') {
+        cmd = 'npx';
+        cmdArgs = [binary, ...args];
+    } else {
+        // bun astro, pnpm astro, yarn astro
+        // yarn might need 'yarn run' or just 'yarn' if bin is exposed? 'yarn astro' works.
+        cmdArgs = [binary, ...args];
+    }
+
+    await execa(cmd, cmdArgs, {
+        cwd: projectDir,
+        stdio: 'inherit',
+        preferLocal: true,
+    });
+}
+
+export async function getRunInstruction(script) {
+    const manager = await getPackageManager();
+    if (manager === 'npm') {
+        return `npm run ${script}`;
+    }
+    return `${manager} run ${script}`;
+}
+
+export async function getInstallInstruction() {
+    const manager = await getPackageManager();
+    return `${manager} install`;
+}