@chappibunny/repolens 1.12.2 → 1.13.0

package/src/cli.js

@@ -1,7 +1,7 @@
 import "dotenv/config";
 import fs from "node:fs/promises";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { createInterface } from "node:readline/promises";
 import { loadConfig } from "./core/config.js";
 import { scanRepo } from "./core/scan.js";
@@ -29,6 +29,9 @@ import { generateDocumentSet } from "./docs/generate-doc-set.js";
 import { writeDocumentSet } from "./docs/write-doc-set.js";
 import { loadPlugins } from "./plugins/loader.js";
 import { PluginManager } from "./plugins/manager.js";
+import { printHelp } from "./help.js";
+import { parseCliArgs } from "./cli-args.js";
+import { isNonInteractiveEnvironment } from "./utils/interactive.js";
 import { 
   initTelemetry, 
   captureError, 
@@ -219,56 +222,33 @@ async function findConfig(startDir = process.cwd()) {
   }
 }
 
-function printHelp() {
-  console.log(`
-RepoLens — Repository Intelligence CLI
-
-Usage:
-  repolens <command> [options]
-
-Commands:
-  init        Scaffold RepoLens files in your repository
-  doctor      Validate your RepoLens setup
-  migrate     Upgrade workflow files to current format
-  publish     Scan, render, and publish documentation
-  demo        Generate local docs without API keys (quick preview)
-  watch       Watch for file changes and regenerate docs
-  uninstall   Remove all RepoLens-generated files from your repository
-  feedback    Send feedback to the RepoLens team
-  version     Print the current RepoLens version
-
-Options:
-  --config        Path to .repolens.yml (auto-discovered if not provided)
-  --target        Target repository path for init/doctor/migrate
-  --quick         Run init with minimal prompts (skip wizard)
-  --dry-run       Preview migration changes without applying them
-  --force         Skip interactive confirmation for migration
-  --verbose       Enable verbose logging
-  --version       Print version
-  --help          Show this help message
-
-Examples:
-  repolens init                                 # Full interactive wizard (recommended)
-  repolens init --quick                         # Minimal setup, skip wizard
-  repolens init --target /tmp/my-repo
-  repolens doctor --target /tmp/my-repo
-  repolens migrate                              # Migrate workflows in current directory
-  repolens migrate --dry-run                    # Preview changes without applying
-  repolens publish                              # Auto-discovers .repolens.yml
-  repolens publish --config /path/.repolens.yml # Explicit config path
-  repolens demo                                  # Quick local preview (no API keys)
-  repolens watch                                # Watch mode (Markdown only)
-  repolens uninstall                             # Remove all RepoLens files
-  repolens uninstall --target /tmp/my-repo       # Uninstall from specific repo
-  repolens --version
-`);
-}
-
 async function main() {
-  const command = process.argv[2];
+  const parsed = parseCliArgs(process.argv.slice(2));
+
+  // Help and version return before telemetry and the update check.
+  // bin/repolens.js answers --version/--help without loading this module.
+  if (parsed.help) {
+    printHelp();
+    return;
+  }
 
-  // Initialize telemetry (opt-in via REPOLENS_TELEMETRY_ENABLED=true)
-  initTelemetry();
+  if (parsed.version) {
+    const version = await getPackageVersion();
+    console.log(version);
+    return;
+  }
+
+  if (parsed.errors.length > 0) {
+    for (const message of parsed.errors) error(message);
+    error("Run 'repolens help' for usage information.");
+    process.exit(EXIT_VALIDATION);
+  }
+
+  const command = parsed.command;
+
+  // Initialize telemetry (opt-in via REPOLENS_TELEMETRY_ENABLED=true).
+  // @sentry/node is optional; init is a no-op when it is not installed.
+  await initTelemetry();
   setContext("cli", {
     command: command || "publish",
     args: process.argv.slice(2),
@@ -279,17 +259,6 @@ async function main() {
   // Check for updates (non-blocking, runs in background)
   checkForUpdates().catch(() => {/* Silently fail */});
 
-  if (command === "--help" || command === "-h" || command === "help") {
-    printHelp();
-    return;
-  }
-
-  if (command === "--version" || command === "-v" || command === "version") {
-    const version = await getPackageVersion();
-    console.log(version);
-    return;
-  }
-
   if (command === "init") {
     await printBanner();
     const targetDir = getArg("--target") || process.cwd();
@@ -392,13 +361,6 @@ async function main() {
     return;
   }
 
-  // Reject unknown flags/commands before falling through to publish
-  if (command && command.startsWith("--") && !["--help", "-h", "--version", "-v"].includes(command)) {
-    error(`Unknown option: ${command}`);
-    error("Run 'repolens help' for usage information.");
-    process.exit(EXIT_ERROR);
-  }
-
   if (command === "publish" || !command) {
     await printBanner();
     
@@ -461,7 +423,7 @@ async function main() {
       process.exit(EXIT_ERROR);
     }
 
-    const rawDiff = getGitDiff("origin/main");
+    const rawDiff = getGitDiff("origin/main", cfg.__repoRoot || process.cwd());
     const diffData = buildArchitectureDiffData(rawDiff);
 
     try {
@@ -534,10 +496,12 @@ async function main() {
     const commandTimer = startTimer("demo");
     const targetDir = getArg("--target") || process.cwd();
     
-    // Try to load existing config, otherwise use sensible defaults
+    // Try to load existing config, otherwise use sensible defaults.
+    // Start at --target so a demo of another directory does not pick up
+    // the config in the shell's current directory.
     let cfg;
     try {
-      const configPath = getArg("--config") || await findConfig();
+      const configPath = getArg("--config") || await findConfig(targetDir);
       info(`Using config: ${configPath}`);
       cfg = await loadConfig(configPath);
     } catch {
@@ -580,7 +544,7 @@ async function main() {
       stopTimer(scanTimer);
       info(`Detected ${scan.modules?.length || 0} modules, ${scan.filesCount || 0} files`);
       
-      const rawDiff = getGitDiff("origin/main");
+      const rawDiff = getGitDiff("origin/main", cfg.__repoRoot || targetDir);
       
       info("Generating documentation set...");
       const renderTimer = startTimer("render");
@@ -675,7 +639,7 @@ async function main() {
       const isTest = process.env.NODE_ENV === "test" || process.env.VITEST;
       
       if (isCI || isTest) {
-        info("\nCI/test environment detected — skipping confirmation (use --force to suppress this message).");
+        info("\nNon-interactive environment: removing RepoLens files without a prompt. Pass --force to hide this notice.");
       } else {
         const confirmed = await promptYesNo(`\nRemove ${found.length} item${found.length === 1 ? "" : "s"}? This cannot be undone.`, false);
         
@@ -717,6 +681,11 @@ async function main() {
 
   if (command === "feedback") {
     await printBanner();
+    if (isNonInteractiveEnvironment()) {
+      error("feedback needs an interactive terminal.");
+      await closeTelemetry();
+      process.exit(EXIT_VALIDATION);
+    }
     info("Send feedback to the RepoLens team");
     info("Your feedback is anonymous and helps us improve RepoLens.\n");
 
@@ -754,6 +723,8 @@ async function main() {
       captureError(err, { command: "feedback" });
       error("Failed to send feedback:");
       error(err.message);
+      await closeTelemetry();
+      process.exit(EXIT_ERROR);
     }
 
     await closeTelemetry();
@@ -765,32 +736,41 @@ async function main() {
   process.exit(EXIT_ERROR);
 }
 
-main().catch(async (err) => {
-  // Capture unexpected errors
-  captureError(err, { 
-    type: "uncaught",
-    command: process.argv[2] || "unknown"
+export function runCli() {
+  return main().catch(async (err) => {
+    // Capture unexpected errors
+    captureError(err, {
+      type: "uncaught",
+      command: process.argv[2] || "unknown"
+    });
+
+    console.error("\n❌ RepoLens encountered an unexpected error:\n");
+
+    if (err.code === "ENOENT") {
+      error(formatError("FILE_NOT_FOUND", err.path));
+    } else if (err.code === "EACCES") {
+      error(formatError("FILE_PERMISSION_DENIED", err.path));
+    } else if (err.message) {
+      error(err.message);
+    } else {
+      error(err);
+    }
+
+    if (process.env.VERBOSE || process.argv.includes("--verbose")) {
+      console.error("\nStack trace:");
+      console.error(err.stack);
+    } else {
+      console.error("\nRun with --verbose for full error details.");
+    }
+
+    await closeTelemetry();
+    process.exit(EXIT_ERROR);
   });
-  
-  console.error("\n❌ RepoLens encountered an unexpected error:\n");
-  
-  if (err.code === "ENOENT") {
-    error(formatError("FILE_NOT_FOUND", err.path));
-  } else if (err.code === "EACCES") {
-    error(formatError("FILE_PERMISSION_DENIED", err.path));
-  } else if (err.message) {
-    error(err.message);
-  } else {
-    error(err);
-  }
-  
-  if (process.env.VERBOSE || process.argv.includes("--verbose")) {
-    console.error("\nStack trace:");
-    console.error(err.stack);
-  } else {
-    console.error("\nRun with --verbose for full error details.");
-  }
-  
-  await closeTelemetry();
-  process.exit(EXIT_ERROR);
-});
+}
+
+// Run only when this file is the process entry (node src/cli.js).
+// bin/repolens.js imports runCli() explicitly so a package import does not start the CLI.
+const entryArg = process.argv[1];
+if (entryArg && pathToFileURL(path.resolve(entryArg)).href === import.meta.url) {
+  runCli();
+}

package/src/core/config-schema.js

@@ -8,7 +8,7 @@
  */
 
 const CURRENT_SCHEMA_VERSION = 1;
-const SUPPORTED_PUBLISHERS = ["notion", "markdown", "confluence", "github_wiki"];
+const SUPPORTED_PUBLISHERS = ["notion", "markdown", "confluence", "github_wiki", "obsidian"];
 const SUPPORTED_PAGE_KEYS = [
   "system_overview",
   "module_catalog",
@@ -218,6 +218,51 @@ export function validateConfig(config) {
     }
   }
 
+  // Validate Obsidian configuration (optional, local vault — no network)
+  if (config.obsidian !== undefined) {
+    if (typeof config.obsidian !== "object" || Array.isArray(config.obsidian) || config.obsidian === null) {
+      errors.push("obsidian must be an object");
+    } else {
+      if (config.obsidian.vault !== undefined) {
+        if (typeof config.obsidian.vault !== "string" || config.obsidian.vault.trim() === "") {
+          errors.push("obsidian.vault must be a non-empty string");
+        } else if (config.obsidian.vault.includes("\0")) {
+          errors.push("obsidian.vault contains a null byte");
+        }
+      }
+      if (config.obsidian.folder !== undefined) {
+        if (typeof config.obsidian.folder !== "string" || config.obsidian.folder.trim() === "") {
+          errors.push("obsidian.folder must be a non-empty string");
+        } else if (config.obsidian.folder.includes("\0")) {
+          errors.push("obsidian.folder contains a null byte");
+        } else if (
+          config.obsidian.folder.startsWith("/") ||
+          config.obsidian.folder.startsWith("\\") ||
+          /^[A-Za-z]:[\\/]/.test(config.obsidian.folder) ||
+          config.obsidian.folder.split(/[\\/]/).some((part) => part === "..")
+        ) {
+          errors.push("obsidian.folder must be a relative path inside the vault");
+        }
+      }
+      if (config.obsidian.branches !== undefined) {
+        if (!Array.isArray(config.obsidian.branches)) {
+          errors.push("obsidian.branches must be an array");
+        } else {
+          config.obsidian.branches.forEach((branch, idx) => {
+            if (typeof branch !== "string") {
+              errors.push(`obsidian.branches[${idx}] must be a string`);
+            }
+          });
+        }
+      }
+      for (const flag of ["index", "frontmatter", "wikilinks"]) {
+        if (config.obsidian[flag] !== undefined && typeof config.obsidian[flag] !== "boolean") {
+          errors.push(`obsidian.${flag} must be a boolean`);
+        }
+      }
+    }
+  }
+
   // Validate Discord configuration (optional)
   if (config.discord !== undefined) {
     if (typeof config.discord !== "object" || Array.isArray(config.discord)) {
@@ -379,6 +424,7 @@ const VALID_CONFIG_KEYS = [
   "notion",
   "confluence",
   "github_wiki",
+  "obsidian",
   "discord",
   "features",
   "ai",

package/src/core/config.js

@@ -1,14 +1,17 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import yaml from "js-yaml";
 import { validateConfig as validateSchema } from "./config-schema.js";
 import { validateConfig } from "../utils/validate.js";
 import { warn, error } from "../utils/logger.js";
+import { loadYaml } from "../utils/yaml.js";
 
 export async function loadConfig(configPath) {
   const absoluteConfigPath = path.resolve(configPath);
   const raw = await fs.readFile(absoluteConfigPath, "utf8");
-  const cfg = yaml.load(raw);
+  const cfg = loadYaml(raw);
+  if (!cfg || typeof cfg !== "object" || Array.isArray(cfg)) {
+    throw new Error("Configuration must be a YAML mapping");
+  }
 
   // Validate config against schema (structure)
   validateSchema(cfg);

package/src/core/diff.js

@@ -1,20 +1,49 @@
-import { execSync } from "node:child_process";
+import { execFileSync } from "node:child_process";
 import { warn } from "../utils/logger.js";
 
-export function getGitDiff(baseRef = "origin/main") {
+const SAFE_REF = /^[A-Za-z0-9._~^/@+-]+$/;
+
+function emptyDiff() {
+  return { added: [], removed: [], modified: [] };
+}
+
+/**
+ * Classify one `git diff --name-status` line.
+ * Renames and copies (`R100`, `C75`) record the destination path.
+ */
+export function classifyDiffLine(line) {
+  const parts = String(line || "").split("\t");
+  const status = parts[0];
+  if (!status) return null;
+
+  const file = status.startsWith("R") || status.startsWith("C")
+    ? parts[2] || parts[1]
+    : parts[1];
+  if (!file) return null;
+
+  if (status === "A") return { bucket: "added", file };
+  if (status === "D") return { bucket: "removed", file };
+  return { bucket: "modified", file };
+}
+
+export function getGitDiff(baseRef = "origin/main", cwd = process.cwd()) {
+  if (typeof baseRef !== "string" || baseRef.startsWith("-") || !SAFE_REF.test(baseRef)) {
+    warn("git diff skipped: base ref contains unsupported characters.");
+    return emptyDiff();
+  }
+
   let output = "";
 
   try {
-    output = execSync(`git diff --name-status ${baseRef}`, {
-      encoding: "utf8"
+    // Pipe stderr so a missing repo or ref does not dump git's usage text.
+    output = execFileSync("git", ["diff", "--name-status", baseRef], {
+      encoding: "utf8",
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
     });
   } catch (error) {
     warn("git diff failed, returning empty diff.");
-    return {
-      added: [],
-      removed: [],
-      modified: []
-    };
+    return emptyDiff();
   }
 
   const lines = output.split("\n").filter(Boolean);
@@ -24,17 +53,11 @@ export function getGitDiff(baseRef = "origin/main") {
   const modified = [];
 
   for (const line of lines) {
-    const [status, file] = line.split("\t");
-
-    if (!file) continue;
-
-    if (status === "A") {
-      added.push(file);
-    } else if (status === "D") {
-      removed.push(file);
-    } else {
-      modified.push(file);
-    }
+    const classified = classifyDiffLine(line);
+    if (!classified) continue;
+    if (classified.bucket === "added") added.push(classified.file);
+    else if (classified.bucket === "removed") removed.push(classified.file);
+    else modified.push(classified.file);
   }
 
   return {

package/src/core/scan.js

@@ -4,6 +4,7 @@ import path from "node:path";
 import { info, warn } from "../utils/logger.js";
 import { trackScan } from "../utils/telemetry.js";
 import { detectMonorepo } from "../analyzers/monorepo-detector.js";
+import { isInsideRoot } from "../utils/safe-path.js";
 
 const norm = (p) => p.replace(/\\/g, "/");
 
@@ -71,8 +72,20 @@ function isNextPage(file) {
   return false;
 }
 
+const MAX_SOURCE_BYTES = 1_000_000;
+
 async function readFileSafe(file) {
   try {
+    const stat = await fs.stat(file);
+    if (!stat.isFile() || stat.size > MAX_SOURCE_BYTES) return "";
+    const fh = await fs.open(file, "r");
+    try {
+      const sample = Buffer.alloc(Math.min(8192, stat.size));
+      await fh.read(sample, 0, sample.length, 0);
+      if (sample.includes(0)) return "";
+    } finally {
+      await fh.close();
+    }
     return await fs.readFile(file, "utf8");
   } catch {
     return "";
@@ -466,11 +479,18 @@ function isValidRoutePath(p) {
 export async function scanRepo(cfg) {
   const repoRoot = cfg.__repoRoot;
 
-  const files = await fg(cfg.scan.include, {
-    cwd: repoRoot,
+  const rootResolved = path.resolve(repoRoot);
+  const files = (await fg(cfg.scan.include, {
+    cwd: rootResolved,
     ignore: cfg.scan.ignore,
-    onlyFiles: true
-  });
+    onlyFiles: true,
+    followSymbolicLinks: false,
+    absolute: false
+  })).filter((file) => isInsideRoot(rootResolved, path.resolve(rootResolved, file)));
+
+  if (files.length === 0) {
+    warn("No files matched the scan patterns. Documentation will be mostly empty. Check scan.include in .repolens.yml.");
+  }
 
   // Performance guardrails
   if (files.length > MAX_FILES_LIMIT) {

package/src/delivery/comment.js

@@ -1,6 +1,7 @@
-import { execSync } from "node:child_process";
 import { log } from "../utils/logger.js";
 import { fetchWithRetry } from "../utils/retry.js";
+import { assertGitHubRepo } from "../utils/github-repo.js";
+import { sanitizeSecrets } from "../utils/secrets.js";
 
 function safe(text) {
   return String(text || "").trim();
@@ -72,7 +73,8 @@ async function githubRequest(method, url, body) {
 
   if (!res.ok) {
     const text = await res.text();
-    throw new Error(`GitHub API error ${res.status}: ${text}`);
+    const clipped = sanitizeSecrets(String(text || "").replace(/\s+/g, " ").slice(0, 500));
+    throw new Error(`GitHub API error ${res.status}: ${clipped}`);
   }
 
   return await res.json();
@@ -114,6 +116,7 @@ export async function upsertPrComment(diff) {
     return;
   }
 
+  assertGitHubRepo(repoFull);
   const [owner, repo] = repoFull.split("/");
   const body = buildBody(diff);
 

package/src/docs/write-doc-set.js

@@ -3,13 +3,14 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { info } from "../utils/logger.js";
+import { resolveOutputDir, safeFileName } from "../utils/safe-path.js";
 
 export async function writeDocumentSet(docSet, targetDir = process.cwd()) {
   const { documents, artifacts, config } = docSet;
   
-  // Determine output directory
-  const outputDir = path.join(
-    targetDir, 
+  // Determine output directory. Reject absolute paths and `..` escapes.
+  const outputDir = resolveOutputDir(
+    targetDir,
     config.documentation?.output_dir || ".repolens"
   );
   
@@ -20,9 +21,10 @@ export async function writeDocumentSet(docSet, targetDir = process.cwd()) {
   
   // Write each document
   for (const doc of documents) {
-    const filePath = path.join(outputDir, doc.filename);
+    const fileName = safeFileName(doc.filename);
+    const filePath = path.join(outputDir, fileName);
     await fs.writeFile(filePath, doc.content, "utf8");
-    info(`✓ Wrote ${doc.filename}`);
+    info(`✓ Wrote ${fileName}`);
   }
   
   // Write artifacts if enabled
@@ -59,12 +61,12 @@ export async function writeDocumentSet(docSet, targetDir = process.cwd()) {
   return {
     outputDir,
     documentCount: documents.length,
-    files: documents.map(d => d.filename)
+    files: documents.map(d => safeFileName(d.filename))
   };
 }
 
 export async function readPreviousDocumentSet(targetDir = process.cwd(), config) {
-  const outputDir = path.join(
+  const outputDir = resolveOutputDir(
     targetDir,
     config.documentation?.output_dir || ".repolens"
   );

package/src/doctor.js

@@ -1,6 +1,6 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import yaml from "js-yaml";
+import { loadYaml } from "./utils/yaml.js";
 import { loadConfig } from "./core/config.js";
 import { detectConfigTypos } from "./core/config-schema.js";
 import { info } from "./utils/logger.js";
@@ -118,7 +118,7 @@ export async function runDoctor(targetDir = process.cwd()) {
     let rawConfig = null;
     try {
       const rawYaml = await fs.readFile(repolensConfigPath, "utf8");
-      rawConfig = yaml.load(rawYaml);
+      rawConfig = loadYaml(rawYaml);
       
       // Check for config key typos before validation
       if (rawConfig && typeof rawConfig === "object") {
@@ -204,6 +204,14 @@ export async function runDoctor(targetDir = process.cwd()) {
       );
     }
 
+    if (cfg.publishers.includes("obsidian")) {
+      if (typeof cfg.obsidian?.vault === "string" && cfg.obsidian.vault.trim() !== "") {
+        ok(`Obsidian vault configured (${cfg.obsidian.vault}) — local publisher, no credentials`);
+      } else {
+        warn("obsidian.vault is not set — required to publish into an Obsidian vault");
+      }
+    }
+
     if (cfg.ai?.enabled || process.env.REPOLENS_AI_ENABLED === "true") {
       const aiProvider = process.env.REPOLENS_AI_PROVIDER || "openai_compatible";
       if (aiProvider === "github") {
@@ -218,7 +226,12 @@ export async function runDoctor(targetDir = process.cwd()) {
     }
 
     if (envChecks.length === 0) {
-      ok("No publisher-specific env vars required (Markdown only)");
+      const localPublishers = [];
+      if (cfg.publishers.includes("markdown")) localPublishers.push("Markdown");
+      if (cfg.publishers.includes("obsidian")) localPublishers.push("Obsidian");
+      ok(localPublishers.length > 0
+        ? `No publisher-specific env vars required (${localPublishers.join(" and ")} only)`
+        : "No publisher-specific env vars required");
     }
 
     for (const check of envChecks) {

package/src/help.js

@@ -0,0 +1,54 @@
+export function printHelp() {
+  console.log(`
+RepoLens — Repository Intelligence CLI
+
+Usage:
+  repolens <command> [options]
+
+Commands:
+  init        Scaffold RepoLens files in your repository
+  doctor      Validate your RepoLens setup
+  migrate     Upgrade workflow files to current format
+  publish     Scan, render, and publish documentation
+  demo        Generate local docs without API keys (quick preview)
+  watch       Watch for file changes and regenerate docs
+  uninstall   Remove RepoLens-generated files from a repository
+  feedback    Send feedback to the RepoLens team
+  version     Print the current RepoLens version
+  help        Show this help message
+
+Options:
+  --config <path>   Path to .repolens.yml (auto-discovered if omitted)
+  --target <path>   Repository path for init, doctor, migrate, demo, uninstall
+  --quick           Scaffold without the wizard (also --non-interactive)
+  --dry-run         Preview migration changes without writing them
+  --force           Apply migrate or uninstall without a confirmation prompt
+  --verbose         Print debug logs and full stacks on unexpected errors
+  --version, -v     Print version and exit
+  --help, -h        Show this help message
+
+Non-interactive sessions (CI, pipes, or REPOLENS_NON_INTERACTIVE):
+  init falls back to --quick instead of waiting on the wizard
+  yes/no prompts use their default and do not wait (uninstall defaults to no
+    on a closed terminal outside CI; CI still removes files and tells you so)
+  feedback exits with code 2 because it needs a terminal
+
+Exit codes:
+  0  success (including a cancelled wizard)
+  1  runtime error, or an unknown command
+  2  invalid flags, missing config, or a failed doctor check
+
+Examples:
+  repolens init
+  repolens init --quick
+  repolens init --target /tmp/my-repo
+  repolens doctor --target /tmp/my-repo
+  repolens migrate --dry-run
+  repolens publish
+  repolens publish --config /path/.repolens.yml
+  repolens demo
+  repolens watch
+  repolens uninstall --target /tmp/my-repo
+  repolens --version
+`);
+}

package/src/index.js

@@ -0,0 +1,13 @@
+/**
+ * Programmatic entry for @chappibunny/repolens.
+ *
+ * Importing this module does not start the CLI. The `repolens` binary
+ * lives in bin/repolens.js and calls runCli() from src/cli.js.
+ */
+
+export { loadConfig } from "./core/config.js";
+export { scanRepo } from "./core/scan.js";
+export { generateDocumentSet } from "./docs/generate-doc-set.js";
+export { writeDocumentSet, readPreviousDocumentSet } from "./docs/write-doc-set.js";
+export { publishDocs } from "./publishers/index.js";
+export { runDoctor } from "./doctor.js";