feat: add check-links command, content linter, and enhanced validate

- New `check-links` command for broken link detection
- Content linter for documentation quality checks
- Enhanced `validate` with --content, --links, --all, --strict flags
- Inject llms.txt integration and redirects into Astro config

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: DevRohit06

src/cli.js

@@ -5,6 +5,7 @@ import { devCommand } from "./commands/dev.js";
 import { ejectCommand } from "./commands/eject.js";
 import { initCommand } from "./commands/init.js";
 import { validateCommand } from "./commands/validate.js";
+import { checkLinksCommand } from "./commands/check-links.js";
 import { previewCommand } from "./commands/preview.js";
 import { doctorCommand } from "./commands/doctor.js";
 import { infoCommand } from "./commands/info.js";
@@ -116,8 +117,21 @@ export async function cli() {
     .description("Validate docs-config.json configuration")
     .option("-i, --input <path>", "Path to the docs folder")
     .option("-q, --quiet", "Quiet mode for CI (exit code only)")
+    .option("--content", "Run content quality checks")
+    .option("--links", "Run broken link detection")
+    .option("--all", "Run all checks (config + content + links)")
+    .option("--strict", "Fail on warnings too (for CI)")
     .action(validateCommand);
 
+  // Check links
+  program
+    .command("check-links")
+    .description("Scan documentation for broken internal links")
+    .requiredOption("-i, --input <path>", "Path to the docs folder")
+    .option("--strict", "Exit with code 1 on broken links (CI)")
+    .option("-q, --quiet", "Quiet mode for CI (exit code only)")
+    .action(checkLinksCommand);
+
   // Preview production build
   program
     .command("preview")

src/commands/check-links.js

@@ -0,0 +1,75 @@
+import { resolve } from 'path';
+import { intro, outro, log, spinner } from '@clack/prompts';
+import pc from 'picocolors';
+import { checkLinks } from '../core/link-checker.js';
+
+/**
+ * Check links command — scan docs for broken internal links.
+ */
+export async function checkLinksCommand(options) {
+  try {
+    const inputPath = options.input ? resolve(options.input) : process.cwd();
+
+    // Quiet mode for CI
+    if (options.quiet) {
+      const result = await checkLinks(inputPath);
+      process.exit(result.brokenLinks.length > 0 ? 1 : 0);
+    }
+
+    console.clear();
+    intro(pc.inverse(pc.cyan(' Lito - Check Links ')));
+
+    const s = spinner();
+    s.start('Scanning documentation for broken links...');
+
+    const result = await checkLinks(inputPath);
+
+    if (result.brokenLinks.length === 0) {
+      s.stop(pc.green('All links are valid!'));
+      log.message('');
+      log.success(`Checked ${pc.bold(result.totalLinks)} links across ${pc.bold(result.checkedFiles)} files`);
+      log.message('');
+      outro(pc.green('No broken links found!'));
+      return;
+    }
+
+    s.stop(pc.yellow(`Found ${result.brokenLinks.length} broken link(s)`));
+    log.message('');
+
+    // Group broken links by file
+    const byFile = new Map();
+    for (const bl of result.brokenLinks) {
+      if (!byFile.has(bl.file)) byFile.set(bl.file, []);
+      byFile.get(bl.file).push(bl);
+    }
+
+    for (const [file, links] of byFile) {
+      log.message(pc.bold(pc.cyan(file)));
+      for (const bl of links) {
+        const label = bl.text ? ` (${pc.dim(bl.text)})` : '';
+        log.message(`  ${pc.red('✗')} ${bl.link}${label}`);
+        if (bl.suggestion) {
+          log.message(`    ${pc.dim('Did you mean:')} ${pc.green(bl.suggestion)}`);
+        }
+      }
+      log.message('');
+    }
+
+    log.message(pc.dim('─'.repeat(50)));
+    log.message(`${pc.bold('Summary:')} ${pc.red(result.brokenLinks.length + ' broken')} out of ${result.totalLinks} links in ${result.checkedFiles} files`);
+    log.message('');
+
+    if (options.strict) {
+      outro(pc.red('Link check failed (strict mode)'));
+      process.exit(1);
+    } else {
+      outro(pc.yellow('Link check complete with warnings'));
+    }
+  } catch (error) {
+    log.error(pc.red(error.message));
+    if (error.stack && !options.quiet) {
+      log.error(pc.gray(error.stack));
+    }
+    process.exit(1);
+  }
+}

src/commands/validate.js

@@ -3,6 +3,8 @@ 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';
+import { lintContent } from '../core/content-linter.js';
+import { checkLinks } from '../core/link-checker.js';
 
 /**
  * Validate command - Validate docs-config.json
@@ -12,26 +14,49 @@ export async function validateCommand(options) {
     const inputPath = options.input ? resolve(options.input) : process.cwd();
     const configPath = join(inputPath, 'docs-config.json');
 
+    const runContent = options.content || options.all;
+    const runLinks = options.links || options.all;
+    const strict = options.strict || false;
+
     // Quick mode for CI - just exit with code
     if (options.quiet) {
+      let hasErrors = false;
+
+      // Config validation
       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);
+        if (!result.valid) hasErrors = true;
+
+        // Content linting
+        if (runContent) {
+          const lint = await lintContent(inputPath, { config });
+          const hasLintErrors = lint.issues.some(i => i.severity === 'error');
+          const hasLintWarnings = lint.issues.some(i => i.severity === 'warning');
+          if (hasLintErrors || (strict && hasLintWarnings)) hasErrors = true;
+        }
+
+        // Link checking
+        if (runLinks) {
+          const linkResult = await checkLinks(inputPath);
+          if (linkResult.brokenLinks.length > 0) hasErrors = true;
+        }
       } catch (e) {
-        process.exit(1);
+        hasErrors = true;
       }
+
+      process.exit(hasErrors ? 1 : 0);
     }
 
     console.clear();
     intro(pc.inverse(pc.cyan(' Lito - Validate Configuration ')));
 
     const s = spinner();
 
-    // Check if config file exists
+    // ── Config validation ──
     s.start('Looking for docs-config.json...');
 
     if (!existsSync(configPath)) {
@@ -113,7 +138,89 @@ export async function validateCommand(options) {
     }
 
     log.message('');
-    outro(pc.green('Validation complete!'));
+
+    // Track if any checks failed
+    let hasFailure = false;
+
+    // ── Content linting ──
+    if (runContent) {
+      log.message(pc.dim('─'.repeat(50)));
+      log.message('');
+      s.start('Linting documentation content...');
+
+      const lint = await lintContent(inputPath, { config });
+
+      const errors = lint.issues.filter(i => i.severity === 'error');
+      const warnings = lint.issues.filter(i => i.severity === 'warning');
+
+      if (lint.issues.length === 0) {
+        s.stop(pc.green(`Content is clean (${lint.totalFiles} files checked)`));
+      } else {
+        s.stop(pc.yellow(`Found ${lint.issues.length} issue(s) in ${lint.totalFiles} files`));
+        log.message('');
+
+        if (errors.length > 0) {
+          log.error(pc.bold(`Errors (${errors.length}):`));
+          for (const issue of errors) {
+            log.error(`  ${pc.red('✗')} ${pc.cyan(issue.file)}: ${issue.message} ${pc.dim(`[${issue.rule}]`)}`);
+          }
+          log.message('');
+          hasFailure = true;
+        }
+
+        if (warnings.length > 0) {
+          log.warn(pc.bold(`Warnings (${warnings.length}):`));
+          for (const issue of warnings) {
+            log.warn(`  ${pc.yellow('!')} ${pc.cyan(issue.file)}: ${issue.message} ${pc.dim(`[${issue.rule}]`)}`);
+          }
+          log.message('');
+          if (strict) hasFailure = true;
+        }
+      }
+    }
+
+    // ── Link checking ──
+    if (runLinks) {
+      log.message(pc.dim('─'.repeat(50)));
+      log.message('');
+      s.start('Checking for broken links...');
+
+      const linkResult = await checkLinks(inputPath);
+
+      if (linkResult.brokenLinks.length === 0) {
+        s.stop(pc.green(`All ${linkResult.totalLinks} links are valid (${linkResult.checkedFiles} files)`));
+      } else {
+        s.stop(pc.yellow(`Found ${linkResult.brokenLinks.length} broken link(s)`));
+        log.message('');
+
+        // Group by file
+        const byFile = new Map();
+        for (const bl of linkResult.brokenLinks) {
+          if (!byFile.has(bl.file)) byFile.set(bl.file, []);
+          byFile.get(bl.file).push(bl);
+        }
+
+        for (const [file, links] of byFile) {
+          log.message(`  ${pc.bold(pc.cyan(file))}`);
+          for (const bl of links) {
+            const label = bl.text ? ` (${pc.dim(bl.text)})` : '';
+            log.message(`    ${pc.red('✗')} ${bl.link}${label}`);
+            if (bl.suggestion) {
+              log.message(`      ${pc.dim('Did you mean:')} ${pc.green(bl.suggestion)}`);
+            }
+          }
+        }
+        log.message('');
+        hasFailure = true;
+      }
+    }
+
+    if (hasFailure) {
+      outro(pc.red('Validation complete with errors'));
+      process.exit(1);
+    } else {
+      outro(pc.green('Validation complete!'));
+    }
   } catch (error) {
     log.error(pc.red(error.message));
     if (error.stack && !options.quiet) {

src/core/config.js

@@ -102,6 +102,94 @@ export async function generateConfig(projectDir, options, frameworkConfig = null
     }
   }
 
+  // Inject llms.txt integration into astro.config.mjs
+  if (frameworkName === 'astro' && config.integrations?.llmsTxt?.enabled && config.metadata?.url) {
+    const astroConfigPath = join(projectDir, "astro.config.mjs");
+    if (await pathExists(astroConfigPath)) {
+      let content = await readFile(astroConfigPath, "utf-8");
+
+      // Add import after the last existing import line
+      const importLine = `import astroLlmsTxt from '@4hse/astro-llms-txt';`;
+      if (!content.includes(importLine)) {
+        const lines = content.split('\n');
+        let lastImportIdx = 0;
+        for (let i = 0; i < lines.length; i++) {
+          if (lines[i].startsWith('import ')) lastImportIdx = i;
+        }
+        lines.splice(lastImportIdx + 1, 0, importLine);
+        content = lines.join('\n');
+      }
+
+      // Build the integration call
+      const llmsTitle = config.integrations.llmsTxt.title || config.metadata.name || 'Documentation';
+      const llmsDesc = config.integrations.llmsTxt.description || config.metadata.description || '';
+      const llmsConfig = `    astroLlmsTxt({
+      title: ${JSON.stringify(llmsTitle)},
+      description: ${JSON.stringify(llmsDesc)},
+      docSet: [
+        {
+          title: ${JSON.stringify(llmsTitle + ' - Full Documentation')},
+          description: ${JSON.stringify('Complete documentation content')},
+          url: '/llms-full.txt',
+          include: ['**'],
+          mainSelector: 'article',
+          ignoreSelectors: ['nav', '.sidebar', '.toc', 'footer', '.breadcrumbs'],
+        },
+        {
+          title: ${JSON.stringify(llmsTitle + ' - Structure')},
+          description: ${JSON.stringify('Documentation structure overview')},
+          url: '/llms-small.txt',
+          include: ['**'],
+          onlyStructure: true,
+          mainSelector: 'article',
+          ignoreSelectors: ['nav', '.sidebar', '.toc', 'footer', '.breadcrumbs'],
+        },
+      ],
+    }),`;
+
+      // Insert after sitemap() in integrations array
+      if (content.includes('sitemap(),')) {
+        content = content.replace(
+          'sitemap(),',
+          `sitemap(),\n${llmsConfig}`
+        );
+      } else {
+        // Fallback: insert at start of integrations array
+        content = content.replace(
+          'integrations: [',
+          `integrations: [\n${llmsConfig}`
+        );
+      }
+
+      await writeFile(astroConfigPath, content, "utf-8");
+    }
+  }
+
+  // Inject redirects into astro.config.mjs
+  if (frameworkName === 'astro' && config.redirects && Object.keys(config.redirects).length > 0) {
+    const astroConfigPath = join(projectDir, "astro.config.mjs");
+    if (await pathExists(astroConfigPath)) {
+      let content = await readFile(astroConfigPath, "utf-8");
+
+      // Build redirects object for Astro config
+      const redirectEntries = Object.entries(config.redirects).map(([source, dest]) => {
+        if (typeof dest === 'string') {
+          return `    '${source}': '${dest}'`;
+        }
+        return `    '${source}': { status: ${dest.status || 301}, destination: '${dest.destination}' }`;
+      });
+
+      const redirectsBlock = `  redirects: {\n${redirectEntries.join(',\n')}\n  },`;
+
+      content = content.replace(
+        "export default defineConfig({",
+        `export default defineConfig({\n${redirectsBlock}`
+      );
+
+      await writeFile(astroConfigPath, content, "utf-8");
+    }
+  }
+
   // Update vite.config.js for React/Vue frameworks
   if (['react', 'vue'].includes(frameworkName) && baseUrl && baseUrl !== "/") {
     const viteConfigPath = join(projectDir, "vite.config.js");