@forge-ts/core 0.8.0 → 0.13.0

package/dist/index.js

@@ -1,7 +1,168 @@
+// src/audit.ts
+import { appendFileSync, existsSync, readFileSync } from "fs";
+import { userInfo } from "os";
+import { join } from "path";
+var AUDIT_FILENAME = ".forge-audit.jsonl";
+function getCurrentUser() {
+  try {
+    return userInfo().username;
+  } catch {
+    return "unknown";
+  }
+}
+function appendAuditEvent(rootDir, event) {
+  const filePath = join(rootDir, AUDIT_FILENAME);
+  appendFileSync(filePath, `${JSON.stringify(event)}
+`, "utf-8");
+}
+function readAuditLog(rootDir, options) {
+  const filePath = join(rootDir, AUDIT_FILENAME);
+  if (!existsSync(filePath)) {
+    return [];
+  }
+  const raw = readFileSync(filePath, "utf-8");
+  const lines = raw.split("\n").filter((line) => line.trim().length > 0);
+  let events = lines.map((line) => JSON.parse(line));
+  if (options?.eventType) {
+    events = events.filter((e) => e.event === options.eventType);
+  }
+  events.reverse();
+  if (options?.limit !== void 0 && options.limit >= 0) {
+    events = events.slice(0, options.limit);
+  }
+  return events;
+}
+function formatAuditEvent(event) {
+  const reasonPart = event.reason ? ` \u2014 ${event.reason}` : "";
+  const detailKeys = Object.keys(event.details);
+  const detailPart = detailKeys.length > 0 ? `  ${JSON.stringify(event.details)}` : "";
+  return `[${event.timestamp}] ${event.event} by ${event.user}${reasonPart}${detailPart}`;
+}
+
+// src/bypass.ts
+import { randomUUID } from "crypto";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { userInfo as userInfo2 } from "os";
+import { join as join2 } from "path";
+var BYPASS_FILENAME = ".forge-bypass.json";
+var DEFAULT_BYPASS_CONFIG = {
+  dailyBudget: 3,
+  durationHours: 24
+};
+function getCurrentUser2() {
+  try {
+    return userInfo2().username;
+  } catch {
+    return "unknown";
+  }
+}
+function readBypassFile(rootDir) {
+  const filePath = join2(rootDir, BYPASS_FILENAME);
+  if (!existsSync2(filePath)) {
+    return [];
+  }
+  try {
+    const raw = readFileSync2(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return [];
+  }
+}
+function writeBypassFile(rootDir, records) {
+  const filePath = join2(rootDir, BYPASS_FILENAME);
+  writeFileSync(filePath, `${JSON.stringify(records, null, 2)}
+`, "utf-8");
+}
+function resolveConfig(config) {
+  return {
+    ...DEFAULT_BYPASS_CONFIG,
+    ...config
+  };
+}
+function startOfToday() {
+  const now = /* @__PURE__ */ new Date();
+  return new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate()));
+}
+function createBypass(rootDir, reason, rule, config) {
+  const resolved = resolveConfig(config);
+  const remaining = getRemainingBudget(rootDir, config);
+  if (remaining <= 0) {
+    throw new Error(
+      `Bypass budget exhausted: ${resolved.dailyBudget}/${resolved.dailyBudget} bypasses used today. Wait until tomorrow or increase bypass.dailyBudget in your forge-ts config.`
+    );
+  }
+  const now = /* @__PURE__ */ new Date();
+  const expiresAt = new Date(now.getTime() + resolved.durationHours * 60 * 60 * 1e3);
+  const record = {
+    id: randomUUID(),
+    createdAt: now.toISOString(),
+    expiresAt: expiresAt.toISOString(),
+    reason,
+    rule: rule ?? "all",
+    user: getCurrentUser2()
+  };
+  const records = readBypassFile(rootDir);
+  records.push(record);
+  writeBypassFile(rootDir, records);
+  appendAuditEvent(rootDir, {
+    timestamp: record.createdAt,
+    event: "bypass.create",
+    user: record.user,
+    reason,
+    details: {
+      bypassId: record.id,
+      rule: record.rule,
+      expiresAt: record.expiresAt,
+      durationHours: resolved.durationHours
+    }
+  });
+  return record;
+}
+function getActiveBypasses(rootDir) {
+  const records = readBypassFile(rootDir);
+  const now = /* @__PURE__ */ new Date();
+  return records.filter((r) => new Date(r.expiresAt) > now);
+}
+function isRuleBypassed(rootDir, ruleCode) {
+  const active = getActiveBypasses(rootDir);
+  return active.some((r) => r.rule === ruleCode || r.rule === "all");
+}
+function getRemainingBudget(rootDir, config) {
+  const resolved = resolveConfig(config);
+  const records = readBypassFile(rootDir);
+  const todayStart = startOfToday();
+  const todayCount = records.filter((r) => new Date(r.createdAt) >= todayStart).length;
+  return Math.max(0, resolved.dailyBudget - todayCount);
+}
+function expireOldBypasses(rootDir) {
+  const records = readBypassFile(rootDir);
+  const now = /* @__PURE__ */ new Date();
+  const active = records.filter((r) => new Date(r.expiresAt) > now);
+  const expired = records.filter((r) => new Date(r.expiresAt) <= now);
+  if (expired.length === 0) {
+    return 0;
+  }
+  writeBypassFile(rootDir, active);
+  for (const record of expired) {
+    appendAuditEvent(rootDir, {
+      timestamp: now.toISOString(),
+      event: "bypass.expire",
+      user: record.user,
+      details: {
+        bypassId: record.id,
+        rule: record.rule,
+        createdAt: record.createdAt,
+        expiresAt: record.expiresAt
+      }
+    });
+  }
+  return expired.length;
+}
+
 // src/config.ts
-import { existsSync } from "fs";
+import { existsSync as existsSync3 } from "fs";
 import { readFile } from "fs/promises";
-import { join, resolve } from "path";
+import { join as join3, resolve } from "path";
 import { pathToFileURL } from "url";
 
 // src/types.ts
@@ -17,8 +178,8 @@ var Visibility = /* @__PURE__ */ ((Visibility2) => {
 function defaultConfig(rootDir) {
   return {
     rootDir,
-    tsconfig: join(rootDir, "tsconfig.json"),
-    outDir: join(rootDir, "docs"),
+    tsconfig: join3(rootDir, "tsconfig.json"),
+    outDir: join3(rootDir, "docs"),
     enforce: {
       enabled: true,
       minVisibility: "public" /* Public */,
@@ -30,17 +191,25 @@ function defaultConfig(rootDir) {
         "require-example": "error",
         "require-package-doc": "warn",
         "require-class-member-doc": "error",
-        "require-interface-member-doc": "error"
+        "require-interface-member-doc": "error",
+        "require-tsdoc-syntax": "warn",
+        "require-remarks": "error",
+        "require-default-value": "warn",
+        "require-type-param": "error",
+        "require-see": "warn",
+        "require-release-tag": "error",
+        "require-fresh-guides": "warn",
+        "require-guide-coverage": "warn"
       }
     },
     doctest: {
       enabled: true,
-      cacheDir: join(rootDir, ".cache", "doctest")
+      cacheDir: join3(rootDir, ".cache", "doctest")
     },
     api: {
       enabled: false,
       openapi: false,
-      openapiPath: join(rootDir, "docs", "openapi.json")
+      openapiPath: join3(rootDir, "docs", "openapi.json")
     },
     gen: {
       enabled: true,
@@ -49,6 +218,39 @@ function defaultConfig(rootDir) {
       readmeSync: false
     },
     skill: {},
+    bypass: {
+      dailyBudget: 3,
+      durationHours: 24
+    },
+    tsdoc: {
+      writeConfig: true,
+      customTags: [],
+      enforce: {
+        core: "error",
+        extended: "warn",
+        discretionary: "off"
+      }
+    },
+    guides: {
+      enabled: true,
+      autoDiscover: true,
+      custom: []
+    },
+    guards: {
+      tsconfig: {
+        enabled: true,
+        requiredFlags: ["strict", "strictNullChecks", "noImplicitAny"]
+      },
+      biome: {
+        enabled: false,
+        lockedRules: []
+      },
+      packageJson: {
+        enabled: true,
+        minNodeVersion: "22.0.0",
+        requiredFields: ["type", "engines"]
+      }
+    },
     project: {}
   };
 }
@@ -61,6 +263,10 @@ var KNOWN_TOP_KEYS = /* @__PURE__ */ new Set([
   "api",
   "gen",
   "skill",
+  "bypass",
+  "tsdoc",
+  "guides",
+  "guards",
   "project"
 ]);
 var KNOWN_RULE_KEYS = /* @__PURE__ */ new Set([
@@ -70,8 +276,30 @@ var KNOWN_RULE_KEYS = /* @__PURE__ */ new Set([
   "require-example",
   "require-package-doc",
   "require-class-member-doc",
-  "require-interface-member-doc"
+  "require-interface-member-doc",
+  "require-tsdoc-syntax",
+  "require-remarks",
+  "require-default-value",
+  "require-type-param",
+  "require-see",
+  "require-release-tag",
+  "require-fresh-guides",
+  "require-guide-coverage"
 ]);
+var KNOWN_TSDOC_KEYS = /* @__PURE__ */ new Set(["writeConfig", "customTags", "enforce"]);
+var KNOWN_TSDOC_ENFORCE_KEYS = /* @__PURE__ */ new Set(["core", "extended", "discretionary"]);
+var KNOWN_GUIDES_KEYS = /* @__PURE__ */ new Set(["enabled", "autoDiscover", "custom"]);
+var KNOWN_GUARDS_KEYS = /* @__PURE__ */ new Set(["tsconfig", "biome", "packageJson"]);
+var KNOWN_GUARDS_TSCONFIG_KEYS = /* @__PURE__ */ new Set(["enabled", "requiredFlags"]);
+var KNOWN_GUARDS_BIOME_KEYS = /* @__PURE__ */ new Set(["enabled", "lockedRules"]);
+var KNOWN_GUARDS_PACKAGE_JSON_KEYS = /* @__PURE__ */ new Set(["enabled", "minNodeVersion", "requiredFields"]);
+function validateKnownKeys(obj, knownKeys, section, warnings) {
+  for (const key of Object.keys(obj)) {
+    if (!knownKeys.has(key)) {
+      warnings.push(`Unknown key "${key}" in ${section} \u2014 ignored.`);
+    }
+  }
+}
 function collectUnknownKeyWarnings(partial) {
   const warnings = [];
   for (const key of Object.keys(partial)) {
@@ -88,6 +316,62 @@ function collectUnknownKeyWarnings(partial) {
       }
     }
   }
+  if (partial.tsdoc) {
+    validateKnownKeys(
+      partial.tsdoc,
+      KNOWN_TSDOC_KEYS,
+      "tsdoc",
+      warnings
+    );
+    if (partial.tsdoc.enforce) {
+      validateKnownKeys(
+        partial.tsdoc.enforce,
+        KNOWN_TSDOC_ENFORCE_KEYS,
+        "tsdoc.enforce",
+        warnings
+      );
+    }
+  }
+  if (partial.guides) {
+    validateKnownKeys(
+      partial.guides,
+      KNOWN_GUIDES_KEYS,
+      "guides",
+      warnings
+    );
+  }
+  if (partial.guards) {
+    validateKnownKeys(
+      partial.guards,
+      KNOWN_GUARDS_KEYS,
+      "guards",
+      warnings
+    );
+    if (partial.guards.tsconfig) {
+      validateKnownKeys(
+        partial.guards.tsconfig,
+        KNOWN_GUARDS_TSCONFIG_KEYS,
+        "guards.tsconfig",
+        warnings
+      );
+    }
+    if (partial.guards.biome) {
+      validateKnownKeys(
+        partial.guards.biome,
+        KNOWN_GUARDS_BIOME_KEYS,
+        "guards.biome",
+        warnings
+      );
+    }
+    if (partial.guards.packageJson) {
+      validateKnownKeys(
+        partial.guards.packageJson,
+        KNOWN_GUARDS_PACKAGE_JSON_KEYS,
+        "guards.packageJson",
+        warnings
+      );
+    }
+  }
   for (const w of warnings) {
     console.error(`[forge-ts] warning: ${w}`);
   }
@@ -108,6 +392,20 @@ function mergeWithDefaults(rootDir, partial) {
     api: { ...defaults.api, ...partial.api },
     gen: { ...defaults.gen, ...partial.gen },
     skill: { ...defaults.skill, ...partial.skill },
+    bypass: { ...defaults.bypass, ...partial.bypass },
+    guides: { ...defaults.guides, ...partial.guides },
+    tsdoc: {
+      ...defaults.tsdoc,
+      ...partial.tsdoc,
+      enforce: { ...defaults.tsdoc.enforce, ...partial.tsdoc?.enforce }
+    },
+    guards: {
+      ...defaults.guards,
+      ...partial.guards,
+      tsconfig: { ...defaults.guards.tsconfig, ...partial.guards?.tsconfig },
+      biome: { ...defaults.guards.biome, ...partial.guards?.biome },
+      packageJson: { ...defaults.guards.packageJson, ...partial.guards?.packageJson }
+    },
     project: { ...defaults.project, ...partial.project }
   };
   if (warnings.length > 0) {
@@ -150,11 +448,11 @@ async function loadPackageJsonConfig(pkgPath) {
 async function loadConfig(rootDir) {
   const root = resolve(rootDir ?? process.cwd());
   let config;
-  const candidates = [join(root, "forge-ts.config.ts"), join(root, "forge-ts.config.js")];
+  const candidates = [join3(root, "forge-ts.config.ts"), join3(root, "forge-ts.config.js")];
   let found = false;
   const loadWarnings = [];
   for (const candidate of candidates) {
-    if (existsSync(candidate)) {
+    if (existsSync3(candidate)) {
       const partial = await loadModuleConfig(candidate);
       if (partial) {
         config = mergeWithDefaults(root, partial);
@@ -167,8 +465,8 @@ async function loadConfig(rootDir) {
     }
   }
   if (!found) {
-    const pkgPath2 = join(root, "package.json");
-    if (existsSync(pkgPath2)) {
+    const pkgPath2 = join3(root, "package.json");
+    if (existsSync3(pkgPath2)) {
       const partial = await loadPackageJsonConfig(pkgPath2);
       if (partial) {
         config = mergeWithDefaults(root, partial);
@@ -181,8 +479,8 @@ async function loadConfig(rootDir) {
   } else {
     config = config;
   }
-  const pkgPath = join(root, "package.json");
-  if (existsSync(pkgPath)) {
+  const pkgPath = join3(root, "package.json");
+  if (existsSync3(pkgPath)) {
     try {
       const raw = await readFile(pkgPath, "utf8");
       const pkg = JSON.parse(raw);
@@ -224,6 +522,135 @@ async function loadConfig(rootDir) {
   return config;
 }
 
+// src/lock.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join4 } from "path";
+var LOCK_FILE_NAME = ".forge-lock.json";
+function readLockFile(rootDir) {
+  const lockPath = join4(rootDir, LOCK_FILE_NAME);
+  if (!existsSync4(lockPath)) {
+    return null;
+  }
+  try {
+    const raw = readFileSync3(lockPath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function writeLockFile(rootDir, manifest) {
+  const lockPath = join4(rootDir, LOCK_FILE_NAME);
+  writeFileSync2(lockPath, `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+}
+function removeLockFile(rootDir) {
+  const lockPath = join4(rootDir, LOCK_FILE_NAME);
+  if (!existsSync4(lockPath)) {
+    return false;
+  }
+  try {
+    unlinkSync(lockPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function createLockManifest(config, lockedBy = "forge-ts lock") {
+  const rules = {};
+  for (const [key, value] of Object.entries(config.enforce.rules)) {
+    rules[key] = value;
+  }
+  const lockConfig = { rules };
+  if (config.guards.tsconfig.enabled) {
+    lockConfig.tsconfig = {
+      enabled: config.guards.tsconfig.enabled,
+      requiredFlags: config.guards.tsconfig.requiredFlags
+    };
+  }
+  if (config.guards.biome.enabled) {
+    lockConfig.biome = {
+      enabled: config.guards.biome.enabled,
+      lockedRules: config.guards.biome.lockedRules
+    };
+  }
+  return {
+    version: "1.0.0",
+    lockedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lockedBy,
+    config: lockConfig
+  };
+}
+function validateAgainstLock(config, lock) {
+  const violations = [];
+  const severityRank = {
+    off: 0,
+    warn: 1,
+    error: 2
+  };
+  for (const [ruleName, lockedSeverity] of Object.entries(lock.config.rules)) {
+    const currentSeverity = config.enforce.rules[ruleName] ?? "off";
+    const lockedRank = severityRank[lockedSeverity] ?? 0;
+    const currentRank = severityRank[currentSeverity] ?? 0;
+    if (currentRank < lockedRank) {
+      violations.push({
+        field: `rules.${ruleName}`,
+        locked: lockedSeverity,
+        current: currentSeverity,
+        message: `Rule "${ruleName}" was weakened from "${lockedSeverity}" to "${currentSeverity}". Locked settings cannot be weakened without running "forge-ts unlock --reason=...".`
+      });
+    }
+  }
+  if (lock.config.tsconfig) {
+    const lockedTsconfig = lock.config.tsconfig;
+    if (lockedTsconfig.enabled && !config.guards.tsconfig.enabled) {
+      violations.push({
+        field: "guards.tsconfig.enabled",
+        locked: "true",
+        current: "false",
+        message: 'tsconfig guard was disabled. Locked settings cannot be weakened without running "forge-ts unlock --reason=...".'
+      });
+    }
+    if (lockedTsconfig.requiredFlags && config.guards.tsconfig.enabled) {
+      const currentFlags = new Set(config.guards.tsconfig.requiredFlags);
+      for (const flag of lockedTsconfig.requiredFlags) {
+        if (!currentFlags.has(flag)) {
+          violations.push({
+            field: `guards.tsconfig.requiredFlags.${flag}`,
+            locked: flag,
+            current: "(removed)",
+            message: `tsconfig required flag "${flag}" was removed. Locked settings cannot be weakened without running "forge-ts unlock --reason=...".`
+          });
+        }
+      }
+    }
+  }
+  if (lock.config.biome) {
+    const lockedBiome = lock.config.biome;
+    if (lockedBiome.enabled && !config.guards.biome.enabled) {
+      violations.push({
+        field: "guards.biome.enabled",
+        locked: "true",
+        current: "false",
+        message: 'Biome guard was disabled. Locked settings cannot be weakened without running "forge-ts unlock --reason=...".'
+      });
+    }
+    if (lockedBiome.lockedRules && config.guards.biome.enabled) {
+      const currentRules = new Set(config.guards.biome.lockedRules);
+      for (const rule of lockedBiome.lockedRules) {
+        if (!currentRules.has(rule)) {
+          violations.push({
+            field: `guards.biome.lockedRules.${rule}`,
+            locked: rule,
+            current: "(removed)",
+            message: `Biome locked rule "${rule}" was removed. Locked settings cannot be weakened without running "forge-ts unlock --reason=...".`
+          });
+        }
+      }
+    }
+  }
+  return violations;
+}
+
 // src/visibility.ts
 function resolveVisibility(tags) {
   if (!tags) return "public" /* Public */;
@@ -246,15 +673,34 @@ function filterByVisibility(symbols, minVisibility) {
 }
 
 // src/walker.ts
-import { readFileSync } from "fs";
-import { resolve as resolve2 } from "path";
+import { readFileSync as readFileSync4 } from "fs";
+import { dirname, resolve as resolve2 } from "path";
 import {
   DocNodeKind,
   StandardTags,
   TSDocConfiguration,
   TSDocParser
 } from "@microsoft/tsdoc";
+import { TSDocConfigFile } from "@microsoft/tsdoc-config";
 import ts from "typescript";
+var tsdocConfigCache = /* @__PURE__ */ new Map();
+function clearTSDocConfigCache() {
+  tsdocConfigCache.clear();
+}
+function loadTSDocConfiguration(folderPath) {
+  const cached = tsdocConfigCache.get(folderPath);
+  if (cached) return cached;
+  const configuration = new TSDocConfiguration();
+  try {
+    const configFile = TSDocConfigFile.loadForFolder(folderPath);
+    if (!configFile.fileNotFound && !configFile.hasErrors) {
+      configFile.configureParser(configuration);
+    }
+  } catch {
+  }
+  tsdocConfigCache.set(folderPath, configuration);
+  return configuration;
+}
 function renderInlineNodes(nodes) {
   const parts = [];
   for (const node of nodes) {
@@ -309,8 +755,8 @@ function extractExamples(comment, startLine) {
   }
   return examples;
 }
-function parseTSDoc(rawComment, startLine) {
-  const configuration = new TSDocConfiguration();
+function parseTSDoc(rawComment, startLine, folderPath) {
+  const configuration = folderPath !== void 0 ? loadTSDocConfiguration(folderPath) : new TSDocConfiguration();
   const parser = new TSDocParser(configuration);
   const result = parser.parseString(rawComment);
   const comment = result.docComment;
@@ -362,6 +808,43 @@ function parseTSDoc(rawComment, startLine) {
       }
     }
   }
+  if (comment.remarksBlock) {
+    const remarksText = renderBlock(comment.remarksBlock).trim();
+    tags.remarks = remarksText ? [remarksText] : [];
+  }
+  if (comment.seeBlocks.length > 0) {
+    tags.see = comment.seeBlocks.map((block) => renderBlock(block).trim()).filter(Boolean);
+  }
+  if (comment.typeParams.count > 0) {
+    tags.typeParam = comment.typeParams.blocks.map(
+      (block) => `${block.parameterName} - ${renderBlock(block).trim()}`
+    );
+  }
+  for (const block of comment.customBlocks) {
+    if (block.blockTag.tagName.toLowerCase() === "@defaultvalue") {
+      const dvText = renderBlock(block).trim();
+      if (!tags.defaultValue) tags.defaultValue = [];
+      tags.defaultValue.push(dvText);
+    }
+  }
+  for (const block of comment.customBlocks) {
+    if (block.blockTag.tagName.toLowerCase() === "@concept") {
+      const conceptText = renderBlock(block).trim();
+      if (conceptText) {
+        if (!tags.concept) tags.concept = [];
+        tags.concept.push(conceptText);
+      }
+    }
+  }
+  for (const block of comment.customBlocks) {
+    if (block.blockTag.tagName.toLowerCase() === "@guide") {
+      const guideText = renderBlock(block).trim();
+      if (guideText) {
+        if (!tags.guide) tags.guide = [];
+        tags.guide.push(guideText);
+      }
+    }
+  }
   const examples = extractExamples(comment, startLine);
   const links = [];
   function walkForLinks(node) {
@@ -379,6 +862,14 @@ function parseTSDoc(rawComment, startLine) {
     }
   }
   walkForLinks(comment);
+  const parseMessages = [];
+  for (const msg of result.log.messages) {
+    parseMessages.push({
+      messageId: msg.messageId,
+      text: msg.unformattedText,
+      line: startLine
+    });
+  }
   const summary = renderDocSection(comment.summarySection);
   return {
     summary: summary || void 0,
@@ -388,7 +879,8 @@ function parseTSDoc(rawComment, startLine) {
     examples: examples.length > 0 ? examples : void 0,
     tags: Object.keys(tags).length > 0 ? tags : void 0,
     deprecated,
-    links: links.length > 0 ? links : void 0
+    links: links.length > 0 ? links : void 0,
+    parseMessages: parseMessages.length > 0 ? parseMessages : void 0
   };
 }
 function getLeadingComment(node, sourceFile) {
@@ -439,9 +931,10 @@ function buildSignature(node, checker) {
     return void 0;
   }
 }
-function extractSymbolsFromFile(sourceFile, checker, _tsdocParser) {
+function extractSymbolsFromFile(sourceFile, checker) {
   const symbols = [];
   const filePath = sourceFile.fileName;
+  const fileDir = dirname(filePath);
   function visit(node, parentExported) {
     const isExported = parentExported || (ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Export) !== 0;
     if (ts.isExportDeclaration(node)) {
@@ -458,7 +951,7 @@ function extractSymbolsFromFile(sourceFile, checker, _tsdocParser) {
         const name2 = decl.name.getText(sourceFile);
         const pos2 = sourceFile.getLineAndCharacterOfPosition(decl.getStart());
         const rawComment2 = getLeadingComment(node, sourceFile);
-        const documentation2 = rawComment2 ? parseTSDoc(rawComment2, pos2.line + 1) : void 0;
+        const documentation2 = rawComment2 ? parseTSDoc(rawComment2, pos2.line + 1, fileDir) : void 0;
         const tags2 = documentation2?.tags;
         const visibility2 = resolveVisibility(tags2);
         symbols.push({
@@ -488,7 +981,7 @@ function extractSymbolsFromFile(sourceFile, checker, _tsdocParser) {
     const name = nameNode.getText(sourceFile);
     const pos = sourceFile.getLineAndCharacterOfPosition(node.getStart());
     const rawComment = getLeadingComment(node, sourceFile);
-    const documentation = rawComment ? parseTSDoc(rawComment, pos.line + 1) : void 0;
+    const documentation = rawComment ? parseTSDoc(rawComment, pos.line + 1, fileDir) : void 0;
     const tags = documentation?.tags;
     const visibility = resolveVisibility(tags);
     const children = [];
@@ -499,7 +992,7 @@ function extractSymbolsFromFile(sourceFile, checker, _tsdocParser) {
         const memberName = member.name?.getText(sourceFile) ?? "";
         const memberPos = sourceFile.getLineAndCharacterOfPosition(member.getStart());
         const memberComment = getLeadingComment(member, sourceFile);
-        const memberDoc = memberComment ? parseTSDoc(memberComment, memberPos.line + 1) : void 0;
+        const memberDoc = memberComment ? parseTSDoc(memberComment, memberPos.line + 1, fileDir) : void 0;
         const memberTags = memberDoc?.tags;
         const memberVisibility = resolveVisibility(memberTags);
         children.push({
@@ -535,7 +1028,7 @@ function createWalker(config) {
   return {
     walk() {
       const tsconfigPath = resolve2(config.tsconfig);
-      const configFile = ts.readConfigFile(tsconfigPath, (path) => readFileSync(path, "utf8"));
+      const configFile = ts.readConfigFile(tsconfigPath, (path) => readFileSync4(path, "utf8"));
       if (configFile.error) {
         throw new Error(
           `Failed to read tsconfig at ${tsconfigPath}: ${ts.flattenDiagnosticMessageText(configFile.error.messageText, "\n")}`
@@ -551,14 +1044,12 @@ function createWalker(config) {
         options: parsedCommandLine.options
       });
       const checker = program.getTypeChecker();
-      const tsdocConfiguration = new TSDocConfiguration();
-      const tsdocParser = new TSDocParser(tsdocConfiguration);
       const allSymbols = [];
       for (const sourceFile of program.getSourceFiles()) {
         if (sourceFile.isDeclarationFile || sourceFile.fileName.includes("node_modules")) {
           continue;
         }
-        const fileSymbols = extractSymbolsFromFile(sourceFile, checker, tsdocParser);
+        const fileSymbols = extractSymbolsFromFile(sourceFile, checker);
         allSymbols.push(...fileSymbols);
       }
       return allSymbols;
@@ -567,11 +1058,27 @@ function createWalker(config) {
 }
 export {
   Visibility,
+  appendAuditEvent,
+  clearTSDocConfigCache,
+  createBypass,
+  createLockManifest,
   createWalker,
   defaultConfig,
+  expireOldBypasses,
   filterByVisibility,
+  formatAuditEvent,
+  getActiveBypasses,
+  getCurrentUser,
+  getRemainingBudget,
+  isRuleBypassed,
   loadConfig,
+  loadTSDocConfiguration,
   meetsVisibility,
-  resolveVisibility
+  readAuditLog,
+  readLockFile,
+  removeLockFile,
+  resolveVisibility,
+  validateAgainstLock,
+  writeLockFile
 };
 //# sourceMappingURL=index.js.map