@doccov/cli 0.4.3 → 0.4.5

package/dist/cli.js

@@ -933,8 +933,8 @@ function registerFixCommand(program, dependencies = {}) {
 }
 
 // src/commands/generate.ts
-import * as fs5 from "node:fs";
-import * as path6 from "node:path";
+import * as fs6 from "node:fs";
+import * as path7 from "node:path";
 import { DocCov as DocCov3 } from "@doccov/sdk";
 import { normalize, validateSpec } from "@openpkg-ts/spec";
 import chalk5 from "chalk";
@@ -990,10 +990,118 @@ var mergeFilterOptions = (config, cliOptions) => {
   };
 };
 
+// src/utils/entry-detection.ts
+import * as fs5 from "node:fs";
+import * as path6 from "node:path";
+function detectEntryPoint(repoDir) {
+  const pkgPath = path6.join(repoDir, "package.json");
+  if (!fs5.existsSync(pkgPath)) {
+    throw new Error("No package.json found - not a valid npm package");
+  }
+  let pkg;
+  try {
+    pkg = JSON.parse(fs5.readFileSync(pkgPath, "utf-8"));
+  } catch {
+    throw new Error("Failed to parse package.json");
+  }
+  if (typeof pkg.types === "string") {
+    const resolved = resolveToTs(repoDir, pkg.types);
+    if (resolved) {
+      return { entryPath: resolved, source: "types" };
+    }
+  }
+  if (typeof pkg.typings === "string") {
+    const resolved = resolveToTs(repoDir, pkg.typings);
+    if (resolved) {
+      return { entryPath: resolved, source: "types" };
+    }
+  }
+  const exports = pkg.exports;
+  if (exports) {
+    const mainExport = exports["."];
+    if (typeof mainExport === "object" && mainExport !== null) {
+      const exportObj = mainExport;
+      if (typeof exportObj.types === "string") {
+        const resolved = resolveToTs(repoDir, exportObj.types);
+        if (resolved) {
+          return { entryPath: resolved, source: "exports" };
+        }
+      }
+    }
+  }
+  if (typeof pkg.main === "string") {
+    const resolved = resolveToTs(repoDir, pkg.main);
+    if (resolved) {
+      return { entryPath: resolved, source: "main" };
+    }
+  }
+  if (typeof pkg.module === "string") {
+    const resolved = resolveToTs(repoDir, pkg.module);
+    if (resolved) {
+      return { entryPath: resolved, source: "module" };
+    }
+  }
+  const commonPaths = [
+    "src/index.ts",
+    "src/index.tsx",
+    "src/main.ts",
+    "index.ts",
+    "lib/index.ts",
+    "source/index.ts"
+  ];
+  for (const p of commonPaths) {
+    if (fs5.existsSync(path6.join(repoDir, p))) {
+      return { entryPath: p, source: "fallback" };
+    }
+  }
+  throw new Error("Could not detect TypeScript entry point. No types field in package.json and no common entry paths found.");
+}
+function resolveToTs(baseDir, filePath) {
+  const normalized = filePath.replace(/^\.\//, "");
+  const isSourceTs = normalized.endsWith(".ts") && !normalized.endsWith(".d.ts") || normalized.endsWith(".tsx");
+  if (isSourceTs) {
+    if (fs5.existsSync(path6.join(baseDir, normalized))) {
+      return normalized;
+    }
+  }
+  const candidates = [];
+  if (normalized.startsWith("dist/")) {
+    const srcPath = normalized.replace(/^dist\//, "src/");
+    candidates.push(srcPath.replace(/\.js$/, ".ts"));
+    candidates.push(srcPath.replace(/\.d\.ts$/, ".ts"));
+    candidates.push(srcPath.replace(/\.js$/, ".tsx"));
+  }
+  if (normalized.startsWith("build/")) {
+    const srcPath = normalized.replace(/^build\//, "src/");
+    candidates.push(srcPath.replace(/\.js$/, ".ts"));
+    candidates.push(srcPath.replace(/\.d\.ts$/, ".ts"));
+  }
+  if (normalized.startsWith("lib/")) {
+    const srcPath = normalized.replace(/^lib\//, "src/");
+    candidates.push(srcPath.replace(/\.js$/, ".ts"));
+    candidates.push(srcPath.replace(/\.d\.ts$/, ".ts"));
+  }
+  candidates.push(normalized.replace(/\.js$/, ".ts"));
+  candidates.push(normalized.replace(/\.d\.ts$/, ".ts"));
+  candidates.push(normalized.replace(/\.js$/, ".tsx"));
+  if (normalized.endsWith(".d.ts")) {
+    const baseName = path6.basename(normalized, ".d.ts");
+    candidates.push(`src/${baseName}.ts`);
+  }
+  for (const candidate of candidates) {
+    if (candidate.endsWith(".d.ts"))
+      continue;
+    if (fs5.existsSync(path6.join(baseDir, candidate))) {
+      return candidate;
+    }
+  }
+  return;
+}
+
 // src/commands/generate.ts
 var defaultDependencies4 = {
   createDocCov: (options) => new DocCov3(options),
-  writeFileSync: fs5.writeFileSync,
+  writeFileSync: fs6.writeFileSync,
   spinner: (text) => ora3(text),
   log: console.log,
   error: console.error
@@ -1013,7 +1121,7 @@ function stripDocsFields(spec) {
 }
 function formatDiagnosticOutput(prefix, diagnostic, baseDir) {
   const location = diagnostic.location;
-  const relativePath = location?.file ? path6.relative(baseDir, location.file) || location.file : undefined;
+  const relativePath = location?.file ? path7.relative(baseDir, location.file) || location.file : undefined;
   const locationText = location && relativePath ? chalk5.gray(`${relativePath}:${location.line ?? 1}:${location.column ?? 1}`) : null;
   const locationPrefix = locationText ? `${locationText} ` : "";
   return `${prefix} ${locationPrefix}${diagnostic.message}`;
@@ -1033,16 +1141,18 @@ function registerGenerateCommand(program, dependencies = {}) {
           throw new Error(`Package "${options.package}" not found in monorepo`);
         }
         targetDir = packageDir;
-        log(chalk5.gray(`Found package at ${path6.relative(options.cwd, packageDir)}`));
+        log(chalk5.gray(`Found package at ${path7.relative(options.cwd, packageDir)}`));
       }
       if (!entryFile) {
-        entryFile = await findEntryPoint(targetDir, true);
-        log(chalk5.gray(`Auto-detected entry point: ${path6.relative(targetDir, entryFile)}`));
+        const detected = detectEntryPoint(targetDir);
+        entryFile = path7.join(targetDir, detected.entryPath);
+        log(chalk5.gray(`Auto-detected entry point: ${detected.entryPath} (from ${detected.source})`));
       } else {
-        entryFile = path6.resolve(targetDir, entryFile);
-        if (fs5.existsSync(entryFile) && fs5.statSync(entryFile).isDirectory()) {
-          entryFile = await findEntryPoint(entryFile, true);
-          log(chalk5.gray(`Auto-detected entry point: ${entryFile}`));
+        entryFile = path7.resolve(targetDir, entryFile);
+        if (fs6.existsSync(entryFile) && fs6.statSync(entryFile).isDirectory()) {
+          const detected = detectEntryPoint(entryFile);
+          entryFile = path7.join(entryFile, detected.entryPath);
+          log(chalk5.gray(`Auto-detected entry point: ${detected.entryPath} (from ${detected.source})`));
         }
       }
       const resolveExternalTypes = !options.skipResolve;
@@ -1054,7 +1164,7 @@ function registerGenerateCommand(program, dependencies = {}) {
       try {
         config = await loadDocCovConfig(targetDir);
         if (config?.filePath) {
-          log(chalk5.gray(`Loaded configuration from ${path6.relative(targetDir, config.filePath)}`));
+          log(chalk5.gray(`Loaded configuration from ${path7.relative(targetDir, config.filePath)}`));
         }
       } catch (configError) {
         error(chalk5.red("Failed to load DocCov config:"), configError instanceof Error ? configError.message : configError);
@@ -1086,7 +1196,7 @@ function registerGenerateCommand(program, dependencies = {}) {
       if (!result) {
         throw new Error("Failed to produce an OpenPkg spec.");
       }
-      const outputPath = path6.resolve(process.cwd(), options.output);
+      const outputPath = path7.resolve(process.cwd(), options.output);
       let normalized = normalize(result.spec);
       if (options.docs === false) {
         normalized = stripDocsFields(normalized);
@@ -1119,23 +1229,23 @@ function registerGenerateCommand(program, dependencies = {}) {
 }
 
 // src/commands/init.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 chalk6 from "chalk";
 var defaultDependencies5 = {
-  fileExists: fs6.existsSync,
-  writeFileSync: fs6.writeFileSync,
-  readFileSync: fs6.readFileSync,
+  fileExists: fs7.existsSync,
+  writeFileSync: fs7.writeFileSync,
+  readFileSync: fs7.readFileSync,
   log: console.log,
   error: console.error
 };
 function registerInitCommand(program, dependencies = {}) {
-  const { fileExists: fileExists2, writeFileSync: writeFileSync3, readFileSync: readFileSync4, log, error } = {
+  const { fileExists: fileExists2, writeFileSync: writeFileSync3, readFileSync: readFileSync5, log, error } = {
     ...defaultDependencies5,
     ...dependencies
   };
   program.command("init").description("Create a DocCov configuration file").option("--cwd <dir>", "Working directory", process.cwd()).option("--format <format>", "Config format: auto, mjs, js, cjs", "auto").action((options) => {
-    const cwd = path7.resolve(options.cwd);
+    const cwd = path8.resolve(options.cwd);
     const formatOption = String(options.format ?? "auto").toLowerCase();
     if (!isValidFormat(formatOption)) {
       error(chalk6.red(`Invalid format "${formatOption}". Use auto, mjs, js, or cjs.`));
@@ -1144,17 +1254,17 @@ function registerInitCommand(program, dependencies = {}) {
     }
     const existing = findExistingConfig(cwd, fileExists2);
     if (existing) {
-      error(chalk6.red(`A DocCov config already exists at ${path7.relative(cwd, existing) || "./doccov.config.*"}.`));
+      error(chalk6.red(`A DocCov config already exists at ${path8.relative(cwd, existing) || "./doccov.config.*"}.`));
       process.exitCode = 1;
       return;
     }
-    const packageType = detectPackageType(cwd, fileExists2, readFileSync4);
+    const packageType = detectPackageType(cwd, fileExists2, readFileSync5);
     const targetFormat = resolveFormat(formatOption, packageType);
     if (targetFormat === "js" && packageType !== "module") {
       log(chalk6.yellow('Package is not marked as "type": "module"; creating doccov.config.js may require enabling ESM.'));
     }
     const fileName = `doccov.config.${targetFormat}`;
-    const outputPath = path7.join(cwd, fileName);
+    const outputPath = path8.join(cwd, fileName);
     if (fileExists2(outputPath)) {
       error(chalk6.red(`Cannot create ${fileName}; file already exists.`));
       process.exitCode = 1;
@@ -1162,18 +1272,18 @@ function registerInitCommand(program, dependencies = {}) {
     }
     const template = buildTemplate(targetFormat);
     writeFileSync3(outputPath, template, { encoding: "utf8" });
-    log(chalk6.green(`✓ Created ${path7.relative(process.cwd(), outputPath)}`));
+    log(chalk6.green(`✓ Created ${path8.relative(process.cwd(), outputPath)}`));
   });
 }
 var isValidFormat = (value) => {
   return value === "auto" || value === "mjs" || value === "js" || value === "cjs";
 };
 var findExistingConfig = (cwd, fileExists2) => {
-  let current = path7.resolve(cwd);
-  const { root } = path7.parse(current);
+  let current = path8.resolve(cwd);
+  const { root } = path8.parse(current);
   while (true) {
     for (const candidate of DOCCOV_CONFIG_FILENAMES) {
-      const candidatePath = path7.join(current, candidate);
+      const candidatePath = path8.join(current, candidate);
       if (fileExists2(candidatePath)) {
         return candidatePath;
       }
@@ -1181,17 +1291,17 @@ var findExistingConfig = (cwd, fileExists2) => {
     if (current === root) {
       break;
     }
-    current = path7.dirname(current);
+    current = path8.dirname(current);
   }
   return null;
 };
-var detectPackageType = (cwd, fileExists2, readFileSync4) => {
+var detectPackageType = (cwd, fileExists2, readFileSync5) => {
   const packageJsonPath = findNearestPackageJson(cwd, fileExists2);
   if (!packageJsonPath) {
     return;
   }
   try {
-    const raw = readFileSync4(packageJsonPath, "utf8");
+    const raw = readFileSync5(packageJsonPath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.type === "module") {
       return "module";
@@ -1203,17 +1313,17 @@ var detectPackageType = (cwd, fileExists2, readFileSync4) => {
   return;
 };
 var findNearestPackageJson = (cwd, fileExists2) => {
-  let current = path7.resolve(cwd);
-  const { root } = path7.parse(current);
+  let current = path8.resolve(cwd);
+  const { root } = path8.parse(current);
   while (true) {
-    const candidate = path7.join(current, "package.json");
+    const candidate = path8.join(current, "package.json");
     if (fileExists2(candidate)) {
       return candidate;
     }
     if (current === root) {
       break;
     }
-    current = path7.dirname(current);
+    current = path8.dirname(current);
   }
   return null;
 };
@@ -1249,8 +1359,8 @@ var buildTemplate = (format) => {
 };
 
 // src/commands/report.ts
-import * as fs7 from "node:fs";
-import * as path8 from "node:path";
+import * as fs8 from "node:fs";
+import * as path9 from "node:path";
 import { DocCov as DocCov4 } from "@doccov/sdk";
 import chalk7 from "chalk";
 import ora4 from "ora";
@@ -1430,8 +1540,8 @@ function registerReportCommand(program) {
     try {
       let spec;
       if (options.spec) {
-        const specPath = path8.resolve(options.cwd, options.spec);
-        spec = JSON.parse(fs7.readFileSync(specPath, "utf-8"));
+        const specPath = path9.resolve(options.cwd, options.spec);
+        spec = JSON.parse(fs8.readFileSync(specPath, "utf-8"));
       } else {
         let targetDir = options.cwd;
         let entryFile = entry;
@@ -1444,7 +1554,7 @@ function registerReportCommand(program) {
         if (!entryFile) {
           entryFile = await findEntryPoint(targetDir, true);
         } else {
-          entryFile = path8.resolve(targetDir, entryFile);
+          entryFile = path9.resolve(targetDir, entryFile);
         }
         const spinner = ora4("Analyzing...").start();
         const resolveExternalTypes = !options.skipResolve;
@@ -1465,8 +1575,8 @@ function registerReportCommand(program) {
         output = renderMarkdown(stats, { limit });
       }
       if (options.out) {
-        const outPath = path8.resolve(options.cwd, options.out);
-        fs7.writeFileSync(outPath, output);
+        const outPath = path9.resolve(options.cwd, options.out);
+        fs8.writeFileSync(outPath, output);
         console.log(chalk7.green(`Report written to ${outPath}`));
       } else {
         console.log(output);
@@ -1487,111 +1597,6 @@ import chalk8 from "chalk";
 import ora5 from "ora";
 import { simpleGit } from "simple-git";
 
-// src/utils/entry-detection.ts
-import * as fs8 from "node:fs";
-import * as path9 from "node:path";
-function detectEntryPoint(repoDir) {
-  const pkgPath = path9.join(repoDir, "package.json");
-  if (!fs8.existsSync(pkgPath)) {
-    throw new Error("No package.json found - not a valid npm package");
-  }
-  let pkg;
-  try {
-    pkg = JSON.parse(fs8.readFileSync(pkgPath, "utf-8"));
-  } catch {
-    throw new Error("Failed to parse package.json");
-  }
-  if (typeof pkg.types === "string") {
-    const resolved = resolveToTs(repoDir, pkg.types);
-    if (resolved) {
-      return { entryPath: resolved, source: "types" };
-    }
-  }
-  if (typeof pkg.typings === "string") {
-    const resolved = resolveToTs(repoDir, pkg.typings);
-    if (resolved) {
-      return { entryPath: resolved, source: "types" };
-    }
-  }
-  const exports = pkg.exports;
-  if (exports) {
-    const mainExport = exports["."];
-    if (typeof mainExport === "object" && mainExport !== null) {
-      const exportObj = mainExport;
-      if (typeof exportObj.types === "string") {
-        const resolved = resolveToTs(repoDir, exportObj.types);
-        if (resolved) {
-          return { entryPath: resolved, source: "exports" };
-        }
-      }
-    }
-  }
-  if (typeof pkg.main === "string") {
-    const resolved = resolveToTs(repoDir, pkg.main);
-    if (resolved) {
-      return { entryPath: resolved, source: "main" };
-    }
-  }
-  if (typeof pkg.module === "string") {
-    const resolved = resolveToTs(repoDir, pkg.module);
-    if (resolved) {
-      return { entryPath: resolved, source: "module" };
-    }
-  }
-  const commonPaths = [
-    "src/index.ts",
-    "src/index.tsx",
-    "src/main.ts",
-    "index.ts",
-    "lib/index.ts",
-    "source/index.ts"
-  ];
-  for (const p of commonPaths) {
-    if (fs8.existsSync(path9.join(repoDir, p))) {
-      return { entryPath: p, source: "fallback" };
-    }
-  }
-  throw new Error("Could not detect TypeScript entry point. No types field in package.json and no common entry paths found.");
-}
-function resolveToTs(baseDir, filePath) {
-  const normalized = filePath.replace(/^\.\//, "");
-  if (normalized.endsWith(".ts") || normalized.endsWith(".tsx")) {
-    if (fs8.existsSync(path9.join(baseDir, normalized))) {
-      return normalized;
-    }
-  }
-  const candidates = [];
-  if (normalized.startsWith("dist/")) {
-    const srcPath = normalized.replace(/^dist\//, "src/");
-    candidates.push(srcPath.replace(/\.js$/, ".ts"));
-    candidates.push(srcPath.replace(/\.d\.ts$/, ".ts"));
-    candidates.push(srcPath.replace(/\.js$/, ".tsx"));
-  }
-  if (normalized.startsWith("build/")) {
-    const srcPath = normalized.replace(/^build\//, "src/");
-    candidates.push(srcPath.replace(/\.js$/, ".ts"));
-    candidates.push(srcPath.replace(/\.d\.ts$/, ".ts"));
-  }
-  if (normalized.startsWith("lib/")) {
-    const srcPath = normalized.replace(/^lib\//, "src/");
-    candidates.push(srcPath.replace(/\.js$/, ".ts"));
-    candidates.push(srcPath.replace(/\.d\.ts$/, ".ts"));
-  }
-  candidates.push(normalized.replace(/\.js$/, ".ts"));
-  candidates.push(normalized.replace(/\.d\.ts$/, ".ts"));
-  candidates.push(normalized.replace(/\.js$/, ".tsx"));
-  if (normalized.endsWith(".d.ts")) {
-    const baseName = path9.basename(normalized, ".d.ts");
-    candidates.push(`src/${baseName}.ts`);
-  }
-  for (const candidate of candidates) {
-    if (fs8.existsSync(path9.join(baseDir, candidate))) {
-      return candidate;
-    }
-  }
-  return;
-}
-
 // src/utils/github-url.ts
 function parseGitHubUrl(input, defaultRef = "main") {
   const trimmed = input.trim();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doccov/cli",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "description": "DocCov CLI - Documentation coverage and drift detection for TypeScript",
   "keywords": [
     "typescript",