@doccov/cli 0.5.7 → 0.5.8

package/dist/cli.js

@@ -33,11 +33,22 @@ var docsConfigSchema = z.object({
   include: stringList.optional(),
   exclude: stringList.optional()
 });
+var lintSeveritySchema = z.enum(["error", "warn", "off"]);
+var checkConfigSchema = z.object({
+  lint: z.boolean().optional(),
+  typecheck: z.boolean().optional(),
+  exec: z.boolean().optional()
+});
+var lintConfigSchema = z.object({
+  rules: z.record(lintSeveritySchema).optional()
+});
 var docCovConfigSchema = z.object({
   include: stringList.optional(),
   exclude: stringList.optional(),
   plugins: z.array(z.unknown()).optional(),
-  docs: docsConfigSchema.optional()
+  docs: docsConfigSchema.optional(),
+  check: checkConfigSchema.optional(),
+  lint: lintConfigSchema.optional()
 });
 var normalizeList = (value) => {
   if (!value) {
@@ -61,11 +72,27 @@ var normalizeConfig = (input) => {
       };
     }
   }
+  let check;
+  if (input.check) {
+    check = {
+      lint: input.check.lint,
+      typecheck: input.check.typecheck,
+      exec: input.check.exec
+    };
+  }
+  let lint;
+  if (input.lint) {
+    lint = {
+      rules: input.lint.rules
+    };
+  }
   return {
     include,
     exclude,
     plugins: input.plugins,
-    docs
+    docs,
+    check,
+    lint
   };
 };
 
@@ -142,7 +169,7 @@ ${formatIssues(issues)}`);
 var defineConfig = (config) => config;
 // src/cli.ts
 import { readFileSync as readFileSync5 } from "node:fs";
-import * as path9 from "node:path";
+import * as path11 from "node:path";
 import { fileURLToPath } from "node:url";
 import { Command } from "commander";
 
@@ -161,13 +188,16 @@ import {
   findPackageByName,
   findJSDocLocation,
   generateFixesForExport,
+  getDefaultConfig as getLintDefaultConfig,
   hasNonAssertionComments,
+  lintExport,
   mergeFixes,
   NodeFileSystem,
   parseAssertions,
   parseJSDocToPatch,
   runExamplesWithPackage,
-  serializeJSDoc
+  serializeJSDoc,
+  typecheckExamples
 } from "@doccov/sdk";
 import chalk from "chalk";
 
@@ -274,7 +304,7 @@ function registerCheckCommand(program, dependencies = {}) {
     ...defaultDependencies,
     ...dependencies
   };
-  program.command("check [entry]").description("Fail if documentation coverage falls below a threshold").option("--cwd <dir>", "Working directory", process.cwd()).option("--package <name>", "Target package name (for monorepos)").option("--min-coverage <percentage>", "Minimum docs coverage percentage (0-100)", (value) => Number(value)).option("--require-examples", "Require at least one @example for every export").option("--run-examples", "Execute @example blocks and fail on runtime errors").option("--ignore-drift", "Do not fail on documentation drift").option("--skip-resolve", "Skip external type resolution from node_modules").option("--write", "Auto-fix drift issues").option("--only <types>", "Only fix specific drift types (comma-separated)").option("--dry-run", "Preview fixes without writing (requires --write)").action(async (entry, options) => {
+  program.command("check [entry]").description("Fail if documentation coverage falls below a threshold").option("--cwd <dir>", "Working directory", process.cwd()).option("--package <name>", "Target package name (for monorepos)").option("--min-coverage <percentage>", "Minimum docs coverage percentage (0-100)", (value) => Number(value)).option("--require-examples", "Require at least one @example for every export").option("--exec", "Execute @example blocks at runtime").option("--no-lint", "Skip lint checks").option("--no-typecheck", "Skip example type checking").option("--ignore-drift", "Do not fail on documentation drift").option("--skip-resolve", "Skip external type resolution from node_modules").option("--fix", "Auto-fix drift and lint issues").option("--write", "Alias for --fix").option("--only <types>", "Only fix specific drift types (comma-separated)").option("--dry-run", "Preview fixes without writing (requires --fix)").action(async (entry, options) => {
     try {
       let targetDir = options.cwd;
       let entryFile = entry;
@@ -344,8 +374,56 @@ function registerCheckCommand(program, dependencies = {}) {
         }
         log("");
       }
+      const shouldFix = options.fix || options.write;
+      const lintViolations = [];
+      if (options.lint !== false) {
+        process.stdout.write(chalk.cyan(`> Running lint checks...
+`));
+        const lintConfig = getLintDefaultConfig();
+        for (const exp of spec.exports ?? []) {
+          const violations = lintExport(exp, undefined, lintConfig);
+          for (const violation of violations) {
+            lintViolations.push({ exportName: exp.name, violation });
+          }
+        }
+        if (lintViolations.length === 0) {
+          process.stdout.write(chalk.green(`✓ No lint issues
+`));
+        } else {
+          const errors = lintViolations.filter((v) => v.violation.severity === "error").length;
+          const warns = lintViolations.filter((v) => v.violation.severity === "warn").length;
+          process.stdout.write(chalk.yellow(`⚠ ${lintViolations.length} lint issue(s) (${errors} error, ${warns} warn)
+`));
+        }
+      }
+      const typecheckErrors = [];
+      if (options.typecheck !== false) {
+        const allExamplesForTypecheck = [];
+        for (const exp of spec.exports ?? []) {
+          if (exp.examples && exp.examples.length > 0) {
+            allExamplesForTypecheck.push({ exportName: exp.name, examples: exp.examples });
+          }
+        }
+        if (allExamplesForTypecheck.length > 0) {
+          process.stdout.write(chalk.cyan(`> Type-checking examples...
+`));
+          for (const { exportName, examples } of allExamplesForTypecheck) {
+            const result = typecheckExamples(examples, targetDir);
+            for (const err of result.errors) {
+              typecheckErrors.push({ exportName, error: err });
+            }
+          }
+          if (typecheckErrors.length === 0) {
+            process.stdout.write(chalk.green(`✓ All examples type-check
+`));
+          } else {
+            process.stdout.write(chalk.red(`✗ ${typecheckErrors.length} type error(s)
+`));
+          }
+        }
+      }
       const runtimeDrifts = [];
-      if (options.runExamples) {
+      if (options.exec) {
         const allExamples = [];
         for (const entry2 of spec.exports ?? []) {
           if (entry2.examples && entry2.examples.length > 0) {
@@ -454,7 +532,7 @@ function registerCheckCommand(program, dependencies = {}) {
       const missingExamples = options.requireExamples ? failingExports.filter((item) => item.missing?.includes("examples")) : [];
       let driftExports = [...collectDrift(spec.exports ?? []), ...runtimeDrifts];
       const fixedDriftKeys = new Set;
-      if (options.write && driftExports.length > 0) {
+      if (shouldFix && driftExports.length > 0) {
         const allDrifts = collectDriftsFromExports(spec.exports ?? []);
         const filteredDrifts = filterDriftsByType(allDrifts, options.only);
         if (filteredDrifts.length === 0 && options.only) {
@@ -567,7 +645,9 @@ function registerCheckCommand(program, dependencies = {}) {
       const coverageFailed = coverageScore < minCoverage;
       const hasMissingExamples = missingExamples.length > 0;
       const hasDrift = !options.ignoreDrift && driftExports.length > 0;
-      if (!coverageFailed && !hasMissingExamples && !hasDrift) {
+      const hasLintErrors = lintViolations.filter((v) => v.violation.severity === "error").length > 0;
+      const hasTypecheckErrors = typecheckErrors.length > 0;
+      if (!coverageFailed && !hasMissingExamples && !hasDrift && !hasLintErrors && !hasTypecheckErrors) {
         log(chalk.green(`✓ Docs coverage ${coverageScore}% (min ${minCoverage}%)`));
         if (failingExports.length > 0) {
           log(chalk.gray("Some exports have partial docs:"));
@@ -594,6 +674,20 @@ function registerCheckCommand(program, dependencies = {}) {
       if (hasMissingExamples) {
         error(chalk.red(`${missingExamples.length} export(s) missing examples (required via --require-examples)`));
       }
+      if (hasLintErrors) {
+        error("");
+        error(chalk.bold("Lint errors:"));
+        for (const { exportName, violation } of lintViolations.filter((v) => v.violation.severity === "error").slice(0, 10)) {
+          error(chalk.red(`  • ${exportName}: ${violation.message}`));
+        }
+      }
+      if (hasTypecheckErrors) {
+        error("");
+        error(chalk.bold("Type errors in examples:"));
+        for (const { exportName, error: err } of typecheckErrors.slice(0, 10)) {
+          error(chalk.red(`  • ${exportName} @example ${err.exampleIndex + 1}, line ${err.line}: ${err.message}`));
+        }
+      }
       if (failingExports.length > 0 || driftExports.length > 0) {
         error("");
         error(chalk.bold("Missing documentation details:"));
@@ -1594,17 +1688,225 @@ var buildTemplate = (format) => {
 `);
 };
 
-// src/commands/report.ts
+// src/commands/lint.ts
 import * as fs5 from "node:fs";
 import * as path6 from "node:path";
 import {
-  DocCov as DocCov3,
+  applyEdits as applyEdits2,
+  createSourceFile as createSourceFile2,
   detectEntryPoint as detectEntryPoint3,
   detectMonorepo as detectMonorepo3,
+  DocCov as DocCov3,
+  findJSDocLocation as findJSDocLocation2,
   findPackageByName as findPackageByName3,
-  NodeFileSystem as NodeFileSystem3
+  getDefaultConfig,
+  getRule,
+  lintExport as lintExport2,
+  NodeFileSystem as NodeFileSystem3,
+  serializeJSDoc as serializeJSDoc2
 } from "@doccov/sdk";
 import chalk6 from "chalk";
+var defaultDependencies5 = {
+  createDocCov: (options) => new DocCov3(options),
+  log: console.log,
+  error: console.error
+};
+function getRawJSDoc(exp, targetDir) {
+  if (!exp.source?.file)
+    return;
+  const filePath = path6.resolve(targetDir, exp.source.file);
+  if (!fs5.existsSync(filePath))
+    return;
+  try {
+    const sourceFile = createSourceFile2(filePath);
+    const location = findJSDocLocation2(sourceFile, exp.name, exp.source.line);
+    return location?.existingJSDoc;
+  } catch {
+    return;
+  }
+}
+function registerLintCommand(program, dependencies = {}) {
+  const { createDocCov, log, error } = {
+    ...defaultDependencies5,
+    ...dependencies
+  };
+  program.command("lint [entry]").description("Lint documentation for style and quality issues").option("--cwd <dir>", "Working directory", process.cwd()).option("--package <name>", "Target package name (for monorepos)").option("--fix", "Auto-fix fixable issues").option("--write", "Alias for --fix").option("--rule <name>", "Run only a specific rule").option("--skip-resolve", "Skip external type resolution").action(async (entry, options) => {
+    try {
+      let targetDir = options.cwd;
+      let entryFile = entry;
+      const fileSystem = new NodeFileSystem3(options.cwd);
+      if (options.package) {
+        const mono = await detectMonorepo3(fileSystem);
+        if (!mono.isMonorepo) {
+          throw new Error("Not a monorepo. Remove --package flag.");
+        }
+        const pkg = findPackageByName3(mono.packages, options.package);
+        if (!pkg) {
+          const available = mono.packages.map((p) => p.name).join(", ");
+          throw new Error(`Package "${options.package}" not found. Available: ${available}`);
+        }
+        targetDir = path6.join(options.cwd, pkg.path);
+        log(chalk6.gray(`Found package at ${pkg.path}`));
+      }
+      if (!entryFile) {
+        const targetFs = new NodeFileSystem3(targetDir);
+        const detected = await detectEntryPoint3(targetFs);
+        entryFile = path6.join(targetDir, detected.path);
+        log(chalk6.gray(`Auto-detected entry point: ${detected.path}`));
+      } else {
+        entryFile = path6.resolve(targetDir, entryFile);
+        if (fs5.existsSync(entryFile) && fs5.statSync(entryFile).isDirectory()) {
+          targetDir = entryFile;
+          const dirFs = new NodeFileSystem3(entryFile);
+          const detected = await detectEntryPoint3(dirFs);
+          entryFile = path6.join(entryFile, detected.path);
+          log(chalk6.gray(`Auto-detected entry point: ${detected.path}`));
+        }
+      }
+      const resolveExternalTypes = !options.skipResolve;
+      process.stdout.write(chalk6.cyan(`> Analyzing documentation...
+`));
+      const doccov = createDocCov({ resolveExternalTypes });
+      const specResult = await doccov.analyzeFileWithDiagnostics(entryFile);
+      if (!specResult) {
+        throw new Error("Failed to analyze documentation.");
+      }
+      process.stdout.write(chalk6.cyan(`> Running lint rules...
+`));
+      let config = getDefaultConfig();
+      if (options.rule) {
+        const rule = getRule(options.rule);
+        if (!rule) {
+          throw new Error(`Unknown rule: ${options.rule}`);
+        }
+        const rules = {};
+        for (const key of Object.keys(config.rules)) {
+          rules[key] = "off";
+        }
+        rules[options.rule] = rule.defaultSeverity === "off" ? "warn" : rule.defaultSeverity;
+        config = { rules };
+      }
+      const exportsWithJSDoc = [];
+      for (const exp of specResult.spec.exports ?? []) {
+        const rawJSDoc = getRawJSDoc(exp, targetDir);
+        exportsWithJSDoc.push({
+          export: exp,
+          rawJSDoc,
+          filePath: exp.source?.file ? path6.resolve(targetDir, exp.source.file) : undefined
+        });
+      }
+      const allViolations = [];
+      for (const { export: exp, rawJSDoc, filePath } of exportsWithJSDoc) {
+        const violations = lintExport2(exp, rawJSDoc, config);
+        for (const violation of violations) {
+          allViolations.push({ export: exp, violation, filePath, rawJSDoc });
+        }
+      }
+      const shouldFix = options.fix || options.write;
+      const fixableViolations = allViolations.filter((v) => v.violation.fixable);
+      if (shouldFix && fixableViolations.length > 0) {
+        process.stdout.write(chalk6.cyan(`> Applying fixes...
+`));
+        const edits = [];
+        for (const { export: exp, rawJSDoc, filePath } of fixableViolations) {
+          if (!filePath || !rawJSDoc)
+            continue;
+          if (filePath.endsWith(".d.ts"))
+            continue;
+          const sourceFile = createSourceFile2(filePath);
+          const location = findJSDocLocation2(sourceFile, exp.name, exp.source?.line);
+          if (!location)
+            continue;
+          const rule = getRule("consistent-param-style");
+          if (!rule?.fix)
+            continue;
+          const patch = rule.fix(exp, rawJSDoc);
+          if (!patch)
+            continue;
+          const newJSDoc = serializeJSDoc2(patch, location.indent);
+          edits.push({
+            filePath,
+            symbolName: exp.name,
+            startLine: location.startLine,
+            endLine: location.endLine,
+            hasExisting: location.hasExisting,
+            existingJSDoc: location.existingJSDoc,
+            newJSDoc,
+            indent: location.indent
+          });
+        }
+        if (edits.length > 0) {
+          const result = await applyEdits2(edits);
+          if (result.errors.length > 0) {
+            for (const err of result.errors) {
+              error(chalk6.red(`  ${err.file}: ${err.error}`));
+            }
+          } else {
+            process.stdout.write(chalk6.green(`✓ Fixed ${result.editsApplied} issue(s) in ${result.filesModified} file(s)
+`));
+          }
+          const fixedExports = new Set(edits.map((e) => e.symbolName));
+          const remaining = allViolations.filter((v) => !v.violation.fixable || !fixedExports.has(v.export.name));
+          allViolations.length = 0;
+          allViolations.push(...remaining);
+        }
+      }
+      if (allViolations.length === 0) {
+        log(chalk6.green("✓ No lint issues found"));
+        return;
+      }
+      const byFile = new Map;
+      for (const v of allViolations) {
+        const file = v.filePath ?? "unknown";
+        const existing = byFile.get(file) ?? [];
+        existing.push(v);
+        byFile.set(file, existing);
+      }
+      log("");
+      for (const [filePath, violations] of byFile) {
+        const relativePath = path6.relative(targetDir, filePath);
+        log(chalk6.underline(relativePath));
+        for (const { export: exp, violation } of violations) {
+          const line = exp.source?.line ?? 0;
+          const severity = violation.severity === "error" ? chalk6.red("error") : chalk6.yellow("warning");
+          const fixable = violation.fixable ? chalk6.gray(" (fixable)") : "";
+          log(`  ${line}:1  ${severity}  ${violation.message}  ${chalk6.gray(violation.rule)}${fixable}`);
+        }
+        log("");
+      }
+      const errorCount = allViolations.filter((v) => v.violation.severity === "error").length;
+      const warnCount = allViolations.filter((v) => v.violation.severity === "warn").length;
+      const fixableCount = allViolations.filter((v) => v.violation.fixable).length;
+      const summary = [];
+      if (errorCount > 0)
+        summary.push(chalk6.red(`${errorCount} error(s)`));
+      if (warnCount > 0)
+        summary.push(chalk6.yellow(`${warnCount} warning(s)`));
+      if (fixableCount > 0 && !shouldFix) {
+        summary.push(chalk6.gray(`${fixableCount} fixable with --fix`));
+      }
+      log(summary.join(", "));
+      if (errorCount > 0) {
+        process.exit(1);
+      }
+    } catch (commandError) {
+      error(chalk6.red("Error:"), commandError instanceof Error ? commandError.message : commandError);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/report.ts
+import * as fs6 from "node:fs";
+import * as path7 from "node:path";
+import {
+  DocCov as DocCov4,
+  detectEntryPoint as detectEntryPoint4,
+  detectMonorepo as detectMonorepo4,
+  findPackageByName as findPackageByName4,
+  NodeFileSystem as NodeFileSystem4
+} from "@doccov/sdk";
+import chalk7 from "chalk";
 
 // src/reports/markdown.ts
 function bar(pct, width = 10) {
@@ -1781,42 +2083,42 @@ function registerReportCommand(program) {
     try {
       let spec;
       if (options.spec) {
-        const specPath = path6.resolve(options.cwd, options.spec);
-        spec = JSON.parse(fs5.readFileSync(specPath, "utf-8"));
+        const specPath = path7.resolve(options.cwd, options.spec);
+        spec = JSON.parse(fs6.readFileSync(specPath, "utf-8"));
       } else {
         let targetDir = options.cwd;
         let entryFile = entry;
-        const fileSystem = new NodeFileSystem3(options.cwd);
+        const fileSystem = new NodeFileSystem4(options.cwd);
         if (options.package) {
-          const mono = await detectMonorepo3(fileSystem);
+          const mono = await detectMonorepo4(fileSystem);
           if (!mono.isMonorepo) {
             throw new Error(`Not a monorepo. Remove --package flag for single-package repos.`);
           }
-          const pkg = findPackageByName3(mono.packages, options.package);
+          const pkg = findPackageByName4(mono.packages, options.package);
           if (!pkg) {
             const available = mono.packages.map((p) => p.name).join(", ");
             throw new Error(`Package "${options.package}" not found. Available: ${available}`);
           }
-          targetDir = path6.join(options.cwd, pkg.path);
+          targetDir = path7.join(options.cwd, pkg.path);
         }
         if (!entryFile) {
-          const targetFs = new NodeFileSystem3(targetDir);
-          const detected = await detectEntryPoint3(targetFs);
-          entryFile = path6.join(targetDir, detected.path);
+          const targetFs = new NodeFileSystem4(targetDir);
+          const detected = await detectEntryPoint4(targetFs);
+          entryFile = path7.join(targetDir, detected.path);
         } else {
-          entryFile = path6.resolve(targetDir, entryFile);
+          entryFile = path7.resolve(targetDir, entryFile);
         }
-        process.stdout.write(chalk6.cyan(`> Analyzing...
+        process.stdout.write(chalk7.cyan(`> Analyzing...
 `));
         try {
           const resolveExternalTypes = !options.skipResolve;
-          const doccov = new DocCov3({ resolveExternalTypes });
+          const doccov = new DocCov4({ resolveExternalTypes });
           const result = await doccov.analyzeFileWithDiagnostics(entryFile);
-          process.stdout.write(chalk6.green(`✓ Analysis complete
+          process.stdout.write(chalk7.green(`✓ Analysis complete
 `));
           spec = result.spec;
         } catch (analysisError) {
-          process.stdout.write(chalk6.red(`✗ Analysis failed
+          process.stdout.write(chalk7.red(`✗ Analysis failed
 `));
           throw analysisError;
         }
@@ -1833,35 +2135,35 @@ function registerReportCommand(program) {
         output = renderMarkdown(stats, { limit });
       }
       if (options.out) {
-        const outPath = path6.resolve(options.cwd, options.out);
-        fs5.writeFileSync(outPath, output);
-        console.log(chalk6.green(`Report written to ${outPath}`));
+        const outPath = path7.resolve(options.cwd, options.out);
+        fs6.writeFileSync(outPath, output);
+        console.log(chalk7.green(`Report written to ${outPath}`));
       } else {
         console.log(output);
       }
     } catch (err) {
-      console.error(chalk6.red("Error:"), err instanceof Error ? err.message : err);
+      console.error(chalk7.red("Error:"), err instanceof Error ? err.message : err);
       process.exitCode = 1;
     }
   });
 }
 
 // src/commands/scan.ts
-import * as fs7 from "node:fs";
+import * as fs8 from "node:fs";
 import * as os from "node:os";
-import * as path8 from "node:path";
+import * as path9 from "node:path";
 import {
-  DocCov as DocCov4,
+  DocCov as DocCov5,
   detectBuildInfo,
-  detectEntryPoint as detectEntryPoint4,
-  detectMonorepo as detectMonorepo4,
+  detectEntryPoint as detectEntryPoint5,
+  detectMonorepo as detectMonorepo5,
   detectPackageManager,
-  findPackageByName as findPackageByName4,
+  findPackageByName as findPackageByName5,
   formatPackageList,
   getInstallCommand,
-  NodeFileSystem as NodeFileSystem4
+  NodeFileSystem as NodeFileSystem5
 } from "@doccov/sdk";
-import chalk7 from "chalk";
+import chalk8 from "chalk";
 import { simpleGit } from "simple-git";
 
 // src/utils/github-url.ts
@@ -1895,8 +2197,8 @@ function buildDisplayUrl(parsed) {
 }
 
 // src/utils/llm-build-plan.ts
-import * as fs6 from "node:fs";
-import * as path7 from "node:path";
+import * as fs7 from "node:fs";
+import * as path8 from "node:path";
 import { createAnthropic as createAnthropic3 } from "@ai-sdk/anthropic";
 import { createOpenAI as createOpenAI3 } from "@ai-sdk/openai";
 import { generateObject as generateObject3 } from "ai";
@@ -1932,10 +2234,10 @@ function getModel3() {
 async function gatherContextFiles(repoDir) {
   const sections = [];
   for (const fileName of CONTEXT_FILES) {
-    const filePath = path7.join(repoDir, fileName);
-    if (fs6.existsSync(filePath)) {
+    const filePath = path8.join(repoDir, fileName);
+    if (fs7.existsSync(filePath)) {
       try {
-        let content = fs6.readFileSync(filePath, "utf-8");
+        let content = fs7.readFileSync(filePath, "utf-8");
         if (content.length > MAX_FILE_CHARS) {
           content = `${content.slice(0, MAX_FILE_CHARS)}
 ... (truncated)`;
@@ -1987,14 +2289,14 @@ async function generateBuildPlan(repoDir) {
 }
 
 // src/commands/scan.ts
-var defaultDependencies5 = {
-  createDocCov: (options) => new DocCov4(options),
+var defaultDependencies6 = {
+  createDocCov: (options) => new DocCov5(options),
   log: console.log,
   error: console.error
 };
 function registerScanCommand(program, dependencies = {}) {
   const { createDocCov, log, error } = {
-    ...defaultDependencies5,
+    ...defaultDependencies6,
     ...dependencies
   };
   program.command("scan <url>").description("Analyze docs coverage for any public GitHub repository").option("--ref <branch>", "Branch or tag to analyze").option("--package <name>", "Target package in monorepo").option("--output <format>", "Output format: text or json", "text").option("--no-cleanup", "Keep cloned repo (for debugging)").option("--skip-install", "Skip dependency installation (faster, but may limit type resolution)").option("--skip-resolve", "Skip external type resolution from node_modules").option("--save-spec <path>", "Save full OpenPkg spec to file").action(async (url, options) => {
@@ -2004,12 +2306,12 @@ function registerScanCommand(program, dependencies = {}) {
       const cloneUrl = buildCloneUrl(parsed);
       const displayUrl = buildDisplayUrl(parsed);
       log("");
-      log(chalk7.bold(`Scanning ${displayUrl}`));
-      log(chalk7.gray(`Branch/tag: ${parsed.ref}`));
+      log(chalk8.bold(`Scanning ${displayUrl}`));
+      log(chalk8.gray(`Branch/tag: ${parsed.ref}`));
       log("");
-      tempDir = path8.join(os.tmpdir(), `doccov-scan-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-      fs7.mkdirSync(tempDir, { recursive: true });
-      process.stdout.write(chalk7.cyan(`> Cloning ${parsed.owner}/${parsed.repo}...
+      tempDir = path9.join(os.tmpdir(), `doccov-scan-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+      fs8.mkdirSync(tempDir, { recursive: true });
+      process.stdout.write(chalk8.cyan(`> Cloning ${parsed.owner}/${parsed.repo}...
 `));
       try {
         const git = simpleGit({
@@ -2031,10 +2333,10 @@ function registerScanCommand(program, dependencies = {}) {
         } finally {
           process.env = originalEnv;
         }
-        process.stdout.write(chalk7.green(`✓ Cloned ${parsed.owner}/${parsed.repo}
+        process.stdout.write(chalk8.green(`✓ Cloned ${parsed.owner}/${parsed.repo}
 `));
       } catch (cloneError) {
-        process.stdout.write(chalk7.red(`✗ Failed to clone repository
+        process.stdout.write(chalk8.red(`✗ Failed to clone repository
 `));
         const message = cloneError instanceof Error ? cloneError.message : String(cloneError);
         if (message.includes("Authentication failed") || message.includes("could not read Username") || message.includes("terminal prompts disabled") || message.includes("Invalid username or password") || message.includes("Permission denied")) {
@@ -2050,11 +2352,11 @@ function registerScanCommand(program, dependencies = {}) {
         }
         throw new Error(`Clone failed: ${message}`);
       }
-      const fileSystem = new NodeFileSystem4(tempDir);
+      const fileSystem = new NodeFileSystem5(tempDir);
       if (options.skipInstall) {
-        log(chalk7.gray("Skipping dependency installation (--skip-install)"));
+        log(chalk8.gray("Skipping dependency installation (--skip-install)"));
       } else {
-        process.stdout.write(chalk7.cyan(`> Installing dependencies...
+        process.stdout.write(chalk8.cyan(`> Installing dependencies...
 `));
         const installErrors = [];
         try {
@@ -2104,56 +2406,56 @@ function registerScanCommand(program, dependencies = {}) {
             }
           }
           if (installed) {
-            process.stdout.write(chalk7.green(`✓ Dependencies installed
+            process.stdout.write(chalk8.green(`✓ Dependencies installed
 `));
           } else {
-            process.stdout.write(chalk7.yellow(`⚠ Could not install dependencies (analysis may be limited)
+            process.stdout.write(chalk8.yellow(`⚠ Could not install dependencies (analysis may be limited)
 `));
             for (const err of installErrors) {
-              log(chalk7.gray(`  ${err}`));
+              log(chalk8.gray(`  ${err}`));
             }
           }
         } catch (outerError) {
           const msg = outerError instanceof Error ? outerError.message : String(outerError);
-          process.stdout.write(chalk7.yellow(`⚠ Could not install dependencies: ${msg.slice(0, 100)}
+          process.stdout.write(chalk8.yellow(`⚠ Could not install dependencies: ${msg.slice(0, 100)}
 `));
           for (const err of installErrors) {
-            log(chalk7.gray(`  ${err}`));
+            log(chalk8.gray(`  ${err}`));
           }
         }
       }
       let targetDir = tempDir;
       let packageName;
-      const mono = await detectMonorepo4(fileSystem);
+      const mono = await detectMonorepo5(fileSystem);
       if (mono.isMonorepo) {
         if (!options.package) {
           error("");
-          error(chalk7.red(`Monorepo detected with ${mono.packages.length} packages. Specify target with --package:`));
+          error(chalk8.red(`Monorepo detected with ${mono.packages.length} packages. Specify target with --package:`));
           error("");
           error(formatPackageList(mono.packages));
           error("");
           throw new Error("Monorepo requires --package flag");
         }
-        const pkg = findPackageByName4(mono.packages, options.package);
+        const pkg = findPackageByName5(mono.packages, options.package);
         if (!pkg) {
           error("");
-          error(chalk7.red(`Package "${options.package}" not found. Available packages:`));
+          error(chalk8.red(`Package "${options.package}" not found. Available packages:`));
           error("");
           error(formatPackageList(mono.packages));
           error("");
           throw new Error(`Package not found: ${options.package}`);
         }
-        targetDir = path8.join(tempDir, pkg.path);
+        targetDir = path9.join(tempDir, pkg.path);
         packageName = pkg.name;
-        log(chalk7.gray(`Analyzing package: ${packageName}`));
+        log(chalk8.gray(`Analyzing package: ${packageName}`));
       }
-      process.stdout.write(chalk7.cyan(`> Detecting entry point...
+      process.stdout.write(chalk8.cyan(`> Detecting entry point...
 `));
       let entryPath;
-      const targetFs = mono.isMonorepo ? new NodeFileSystem4(targetDir) : fileSystem;
+      const targetFs = mono.isMonorepo ? new NodeFileSystem5(targetDir) : fileSystem;
       let buildFailed = false;
       const runLlmFallback = async (reason) => {
-        process.stdout.write(chalk7.cyan(`> ${reason}, trying LLM fallback...
+        process.stdout.write(chalk8.cyan(`> ${reason}, trying LLM fallback...
 `));
         const plan = await generateBuildPlan(targetDir);
         if (!plan) {
@@ -2162,88 +2464,88 @@ function registerScanCommand(program, dependencies = {}) {
         if (plan.buildCommands.length > 0) {
           const { execSync } = await import("node:child_process");
           for (const cmd of plan.buildCommands) {
-            log(chalk7.gray(`  Running: ${cmd}`));
+            log(chalk8.gray(`  Running: ${cmd}`));
             try {
               execSync(cmd, { cwd: targetDir, stdio: "pipe", timeout: 300000 });
             } catch (buildError) {
               buildFailed = true;
               const msg = buildError instanceof Error ? buildError.message : String(buildError);
               if (msg.includes("rustc") || msg.includes("cargo") || msg.includes("wasm-pack")) {
-                log(chalk7.yellow(`  ⚠ Build requires Rust toolchain (not available)`));
+                log(chalk8.yellow(`  ⚠ Build requires Rust toolchain (not available)`));
               } else if (msg.includes("rimraf") || msg.includes("command not found")) {
-                log(chalk7.yellow(`  ⚠ Build failed: missing dependencies`));
+                log(chalk8.yellow(`  ⚠ Build failed: missing dependencies`));
               } else {
-                log(chalk7.yellow(`  ⚠ Build failed: ${msg.slice(0, 80)}`));
+                log(chalk8.yellow(`  ⚠ Build failed: ${msg.slice(0, 80)}`));
               }
             }
           }
         }
         if (plan.notes) {
-          log(chalk7.gray(`  Note: ${plan.notes}`));
+          log(chalk8.gray(`  Note: ${plan.notes}`));
         }
         return plan.entryPoint;
       };
       try {
-        const entry = await detectEntryPoint4(targetFs);
+        const entry = await detectEntryPoint5(targetFs);
         const buildInfo = await detectBuildInfo(targetFs);
         const needsBuildStep = entry.isDeclarationOnly && buildInfo.exoticIndicators.wasm;
         if (needsBuildStep) {
-          process.stdout.write(chalk7.cyan(`> Detected .d.ts entry with WASM indicators...
+          process.stdout.write(chalk8.cyan(`> Detected .d.ts entry with WASM indicators...
 `));
           const llmEntry = await runLlmFallback("WASM project detected");
           if (llmEntry) {
-            entryPath = path8.join(targetDir, llmEntry);
+            entryPath = path9.join(targetDir, llmEntry);
             if (buildFailed) {
-              process.stdout.write(chalk7.green(`✓ Entry point: ${llmEntry} (using pre-committed declarations)
+              process.stdout.write(chalk8.green(`✓ Entry point: ${llmEntry} (using pre-committed declarations)
 `));
-              log(chalk7.gray("  Coverage may be limited - generated .d.ts files typically lack JSDoc"));
+              log(chalk8.gray("  Coverage may be limited - generated .d.ts files typically lack JSDoc"));
             } else {
-              process.stdout.write(chalk7.green(`✓ Entry point: ${llmEntry} (from LLM fallback - WASM project)
+              process.stdout.write(chalk8.green(`✓ Entry point: ${llmEntry} (from LLM fallback - WASM project)
 `));
             }
           } else {
-            entryPath = path8.join(targetDir, entry.path);
-            process.stdout.write(chalk7.green(`✓ Entry point: ${entry.path} (from ${entry.source})
+            entryPath = path9.join(targetDir, entry.path);
+            process.stdout.write(chalk8.green(`✓ Entry point: ${entry.path} (from ${entry.source})
 `));
-            log(chalk7.yellow("  ⚠ WASM project detected but no API key - analysis may be limited"));
+            log(chalk8.yellow("  ⚠ WASM project detected but no API key - analysis may be limited"));
           }
         } else {
-          entryPath = path8.join(targetDir, entry.path);
-          process.stdout.write(chalk7.green(`✓ Entry point: ${entry.path} (from ${entry.source})
+          entryPath = path9.join(targetDir, entry.path);
+          process.stdout.write(chalk8.green(`✓ Entry point: ${entry.path} (from ${entry.source})
 `));
         }
       } catch (entryError) {
         const llmEntry = await runLlmFallback("Heuristics failed");
         if (llmEntry) {
-          entryPath = path8.join(targetDir, llmEntry);
-          process.stdout.write(chalk7.green(`✓ Entry point: ${llmEntry} (from LLM fallback)
+          entryPath = path9.join(targetDir, llmEntry);
+          process.stdout.write(chalk8.green(`✓ Entry point: ${llmEntry} (from LLM fallback)
 `));
         } else {
-          process.stdout.write(chalk7.red(`✗ Could not detect entry point (set OPENAI_API_KEY for smart fallback)
+          process.stdout.write(chalk8.red(`✗ Could not detect entry point (set OPENAI_API_KEY for smart fallback)
 `));
           throw entryError;
         }
       }
-      process.stdout.write(chalk7.cyan(`> Analyzing documentation coverage...
+      process.stdout.write(chalk8.cyan(`> Analyzing documentation coverage...
 `));
       let result;
       try {
         const resolveExternalTypes = !options.skipResolve;
         const doccov = createDocCov({ resolveExternalTypes });
         result = await doccov.analyzeFileWithDiagnostics(entryPath);
-        process.stdout.write(chalk7.green(`✓ Analysis complete
+        process.stdout.write(chalk8.green(`✓ Analysis complete
 `));
       } catch (analysisError) {
-        process.stdout.write(chalk7.red(`✗ Analysis failed
+        process.stdout.write(chalk8.red(`✗ Analysis failed
 `));
         throw analysisError;
       }
       const spec = result.spec;
       const coverageScore = spec.docs?.coverageScore ?? 0;
       if (options.saveSpec) {
-        const specPath = path8.resolve(process.cwd(), options.saveSpec);
-        fs7.writeFileSync(specPath, JSON.stringify(spec, null, 2));
-        log(chalk7.green(`✓ Saved spec to ${options.saveSpec}`));
+        const specPath = path9.resolve(process.cwd(), options.saveSpec);
+        fs8.writeFileSync(specPath, JSON.stringify(spec, null, 2));
+        log(chalk8.green(`✓ Saved spec to ${options.saveSpec}`));
       }
       const undocumented = [];
       const driftIssues = [];
@@ -2280,7 +2582,7 @@ function registerScanCommand(program, dependencies = {}) {
         printTextResult(scanResult, log);
       }
     } catch (commandError) {
-      error(chalk7.red("Error:"), commandError instanceof Error ? commandError.message : commandError);
+      error(chalk8.red("Error:"), commandError instanceof Error ? commandError.message : commandError);
       process.exitCode = 1;
     } finally {
       if (tempDir && options.cleanup !== false) {
@@ -2290,63 +2592,180 @@ function registerScanCommand(program, dependencies = {}) {
           stdio: "ignore"
         }).unref();
       } else if (tempDir) {
-        log(chalk7.gray(`Repo preserved at: ${tempDir}`));
+        log(chalk8.gray(`Repo preserved at: ${tempDir}`));
       }
     }
   });
 }
 function printTextResult(result, log) {
   log("");
-  log(chalk7.bold("DocCov Scan Results"));
+  log(chalk8.bold("DocCov Scan Results"));
   log("─".repeat(40));
   const repoName = result.packageName ? `${result.owner}/${result.repo} (${result.packageName})` : `${result.owner}/${result.repo}`;
-  log(`Repository: ${chalk7.cyan(repoName)}`);
-  log(`Branch: ${chalk7.gray(result.ref)}`);
+  log(`Repository: ${chalk8.cyan(repoName)}`);
+  log(`Branch: ${chalk8.gray(result.ref)}`);
   log("");
-  const coverageColor = result.coverage >= 80 ? chalk7.green : result.coverage >= 50 ? chalk7.yellow : chalk7.red;
-  log(chalk7.bold("Coverage"));
+  const coverageColor = result.coverage >= 80 ? chalk8.green : result.coverage >= 50 ? chalk8.yellow : chalk8.red;
+  log(chalk8.bold("Coverage"));
   log(`  ${coverageColor(`${result.coverage}%`)}`);
   log("");
-  log(chalk7.bold("Stats"));
+  log(chalk8.bold("Stats"));
   log(`  ${result.exportCount} exports`);
   log(`  ${result.typeCount} types`);
   log(`  ${result.undocumented.length} undocumented`);
   log(`  ${result.driftCount} drift issues`);
   if (result.undocumented.length > 0) {
     log("");
-    log(chalk7.bold("Undocumented Exports"));
+    log(chalk8.bold("Undocumented Exports"));
     for (const name of result.undocumented.slice(0, 10)) {
-      log(chalk7.yellow(`  ! ${name}`));
+      log(chalk8.yellow(`  ! ${name}`));
     }
     if (result.undocumented.length > 10) {
-      log(chalk7.gray(`  ... and ${result.undocumented.length - 10} more`));
+      log(chalk8.gray(`  ... and ${result.undocumented.length - 10} more`));
     }
   }
   if (result.drift.length > 0) {
     log("");
-    log(chalk7.bold("Drift Issues"));
+    log(chalk8.bold("Drift Issues"));
     for (const d of result.drift.slice(0, 5)) {
-      log(chalk7.red(`  • ${d.export}: ${d.issue}`));
+      log(chalk8.red(`  • ${d.export}: ${d.issue}`));
     }
     if (result.drift.length > 5) {
-      log(chalk7.gray(`  ... and ${result.drift.length - 5} more`));
+      log(chalk8.gray(`  ... and ${result.drift.length - 5} more`));
     }
   }
   log("");
 }
 
+// src/commands/typecheck.ts
+import * as fs9 from "node:fs";
+import * as path10 from "node:path";
+import {
+  detectEntryPoint as detectEntryPoint6,
+  detectMonorepo as detectMonorepo6,
+  DocCov as DocCov6,
+  findPackageByName as findPackageByName6,
+  NodeFileSystem as NodeFileSystem6,
+  typecheckExamples as typecheckExamples2
+} from "@doccov/sdk";
+import chalk9 from "chalk";
+var defaultDependencies7 = {
+  createDocCov: (options) => new DocCov6(options),
+  log: console.log,
+  error: console.error
+};
+function registerTypecheckCommand(program, dependencies = {}) {
+  const { createDocCov, log, error } = {
+    ...defaultDependencies7,
+    ...dependencies
+  };
+  program.command("typecheck [entry]").description("Type-check @example blocks without executing them").option("--cwd <dir>", "Working directory", process.cwd()).option("--package <name>", "Target package name (for monorepos)").option("--skip-resolve", "Skip external type resolution").action(async (entry, options) => {
+    try {
+      let targetDir = options.cwd;
+      let entryFile = entry;
+      const fileSystem = new NodeFileSystem6(options.cwd);
+      if (options.package) {
+        const mono = await detectMonorepo6(fileSystem);
+        if (!mono.isMonorepo) {
+          throw new Error("Not a monorepo. Remove --package flag.");
+        }
+        const pkg = findPackageByName6(mono.packages, options.package);
+        if (!pkg) {
+          const available = mono.packages.map((p) => p.name).join(", ");
+          throw new Error(`Package "${options.package}" not found. Available: ${available}`);
+        }
+        targetDir = path10.join(options.cwd, pkg.path);
+        log(chalk9.gray(`Found package at ${pkg.path}`));
+      }
+      if (!entryFile) {
+        const targetFs = new NodeFileSystem6(targetDir);
+        const detected = await detectEntryPoint6(targetFs);
+        entryFile = path10.join(targetDir, detected.path);
+        log(chalk9.gray(`Auto-detected entry point: ${detected.path}`));
+      } else {
+        entryFile = path10.resolve(targetDir, entryFile);
+        if (fs9.existsSync(entryFile) && fs9.statSync(entryFile).isDirectory()) {
+          targetDir = entryFile;
+          const dirFs = new NodeFileSystem6(entryFile);
+          const detected = await detectEntryPoint6(dirFs);
+          entryFile = path10.join(entryFile, detected.path);
+          log(chalk9.gray(`Auto-detected entry point: ${detected.path}`));
+        }
+      }
+      const resolveExternalTypes = !options.skipResolve;
+      process.stdout.write(chalk9.cyan(`> Analyzing documentation...
+`));
+      const doccov = createDocCov({ resolveExternalTypes });
+      const specResult = await doccov.analyzeFileWithDiagnostics(entryFile);
+      if (!specResult) {
+        throw new Error("Failed to analyze documentation.");
+      }
+      const allExamples = [];
+      for (const exp of specResult.spec.exports ?? []) {
+        if (exp.examples && exp.examples.length > 0) {
+          allExamples.push({ exportName: exp.name, examples: exp.examples });
+        }
+      }
+      if (allExamples.length === 0) {
+        log(chalk9.gray("No @example blocks found"));
+        return;
+      }
+      const totalExamples = allExamples.reduce((sum, e) => sum + e.examples.length, 0);
+      process.stdout.write(chalk9.cyan(`> Type-checking ${totalExamples} example(s)...
+`));
+      const allErrors = [];
+      let passed = 0;
+      let failed = 0;
+      for (const { exportName, examples } of allExamples) {
+        const result = typecheckExamples2(examples, targetDir);
+        for (const err of result.errors) {
+          allErrors.push({ exportName, error: err });
+        }
+        passed += result.passed;
+        failed += result.failed;
+      }
+      if (allErrors.length === 0) {
+        log(chalk9.green(`✓ All ${totalExamples} example(s) passed type checking`));
+        return;
+      }
+      log("");
+      const byExport = new Map;
+      for (const { exportName, error: err } of allErrors) {
+        const existing = byExport.get(exportName) ?? [];
+        existing.push(err);
+        byExport.set(exportName, existing);
+      }
+      for (const [exportName, errors] of byExport) {
+        log(chalk9.red(`✗ ${exportName}`));
+        for (const err of errors) {
+          log(chalk9.gray(`  @example block ${err.exampleIndex + 1}, line ${err.line}:`));
+          log(chalk9.red(`    ${err.message}`));
+        }
+        log("");
+      }
+      log(chalk9.red(`${failed} example(s) failed`) + chalk9.gray(`, ${passed} passed`));
+      process.exit(1);
+    } catch (commandError) {
+      error(chalk9.red("Error:"), commandError instanceof Error ? commandError.message : commandError);
+      process.exit(1);
+    }
+  });
+}
+
 // src/cli.ts
 var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = path9.dirname(__filename2);
-var packageJson = JSON.parse(readFileSync5(path9.join(__dirname2, "../package.json"), "utf-8"));
+var __dirname2 = path11.dirname(__filename2);
+var packageJson = JSON.parse(readFileSync5(path11.join(__dirname2, "../package.json"), "utf-8"));
 var program = new Command;
 program.name("doccov").description("DocCov - Documentation coverage and drift detection for TypeScript").version(packageJson.version);
 registerGenerateCommand(program);
 registerCheckCommand(program);
 registerDiffCommand(program);
 registerInitCommand(program);
+registerLintCommand(program);
 registerReportCommand(program);
 registerScanCommand(program);
+registerTypecheckCommand(program);
 program.command("*", { hidden: true }).action(() => {
   program.outputHelp();
 });

package/dist/config/index.d.ts

@@ -7,22 +7,50 @@ declare const docsConfigSchema: z.ZodObject<{
 	include: z.ZodOptional<typeof stringList>
 	exclude: z.ZodOptional<typeof stringList>
 }>;
+/** Lint severity levels */
+declare const lintSeveritySchema: z.ZodEnum<["error", "warn", "off"]>;
+/**
+* Check command configuration schema
+*/
+declare const checkConfigSchema: z.ZodObject<{
+	lint: z.ZodOptional<z.ZodBoolean>
+	typecheck: z.ZodOptional<z.ZodBoolean>
+	exec: z.ZodOptional<z.ZodBoolean>
+}>;
+/**
+* Lint configuration schema
+*/
+declare const lintConfigSchema: z.ZodObject<{
+	rules: z.ZodOptional<z.ZodRecord<z.ZodString, typeof lintSeveritySchema>>
+}>;
 declare const docCovConfigSchema: z.ZodObject<{
 	include: z.ZodOptional<typeof stringList>
 	exclude: z.ZodOptional<typeof stringList>
 	plugins: z.ZodOptional<z.ZodArray<z.ZodUnknown>>
 	docs: z.ZodOptional<typeof docsConfigSchema>
+	check: z.ZodOptional<typeof checkConfigSchema>
+	lint: z.ZodOptional<typeof lintConfigSchema>
 }>;
 type DocCovConfigInput = z.infer<typeof docCovConfigSchema>;
 interface DocsConfig {
 	include?: string[];
 	exclude?: string[];
 }
+interface CheckConfig {
+	lint?: boolean;
+	typecheck?: boolean;
+	exec?: boolean;
+}
+interface LintRulesConfig {
+	rules?: Record<string, "error" | "warn" | "off">;
+}
 interface NormalizedDocCovConfig {
 	include?: string[];
 	exclude?: string[];
 	plugins?: unknown[];
 	docs?: DocsConfig;
+	check?: CheckConfig;
+	lint?: LintRulesConfig;
 }
 declare const DOCCOV_CONFIG_FILENAMES: readonly ["doccov.config.ts", "doccov.config.mts", "doccov.config.cts", "doccov.config.js", "doccov.config.mjs", "doccov.config.cjs"];
 interface LoadedDocCovConfig extends NormalizedDocCovConfig {
@@ -30,4 +58,4 @@ interface LoadedDocCovConfig extends NormalizedDocCovConfig {
 }
 declare const loadDocCovConfig: (cwd: string) => Promise<LoadedDocCovConfig | null>;
 declare const defineConfig: (config: DocCovConfigInput) => DocCovConfigInput;
-export { loadDocCovConfig, defineConfig, NormalizedDocCovConfig, LoadedDocCovConfig, DocsConfig, DocCovConfigInput, DOCCOV_CONFIG_FILENAMES };
+export { loadDocCovConfig, defineConfig, NormalizedDocCovConfig, LoadedDocCovConfig, LintRulesConfig, DocsConfig, DocCovConfigInput, DOCCOV_CONFIG_FILENAMES, CheckConfig };

package/dist/config/index.js

@@ -32,11 +32,22 @@ var docsConfigSchema = z.object({
   include: stringList.optional(),
   exclude: stringList.optional()
 });
+var lintSeveritySchema = z.enum(["error", "warn", "off"]);
+var checkConfigSchema = z.object({
+  lint: z.boolean().optional(),
+  typecheck: z.boolean().optional(),
+  exec: z.boolean().optional()
+});
+var lintConfigSchema = z.object({
+  rules: z.record(lintSeveritySchema).optional()
+});
 var docCovConfigSchema = z.object({
   include: stringList.optional(),
   exclude: stringList.optional(),
   plugins: z.array(z.unknown()).optional(),
-  docs: docsConfigSchema.optional()
+  docs: docsConfigSchema.optional(),
+  check: checkConfigSchema.optional(),
+  lint: lintConfigSchema.optional()
 });
 var normalizeList = (value) => {
   if (!value) {
@@ -60,11 +71,27 @@ var normalizeConfig = (input) => {
       };
     }
   }
+  let check;
+  if (input.check) {
+    check = {
+      lint: input.check.lint,
+      typecheck: input.check.typecheck,
+      exec: input.check.exec
+    };
+  }
+  let lint;
+  if (input.lint) {
+    lint = {
+      rules: input.lint.rules
+    };
+  }
   return {
     include,
     exclude,
     plugins: input.plugins,
-    docs
+    docs,
+    check,
+    lint
   };
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doccov/cli",
-  "version": "0.5.7",
+  "version": "0.5.8",
   "description": "DocCov CLI - Documentation coverage and drift detection for TypeScript",
   "keywords": [
     "typescript",
@@ -49,7 +49,7 @@
     "@ai-sdk/anthropic": "^1.0.0",
     "@ai-sdk/openai": "^1.0.0",
     "@inquirer/prompts": "^7.8.0",
-    "@doccov/sdk": "^0.5.7",
+    "@doccov/sdk": "^0.5.8",
     "@openpkg-ts/spec": "^0.4.0",
     "ai": "^4.0.0",
     "chalk": "^5.4.1",