core — Functions

() => string

import { getCurrentUser } from "@forge-ts/core/audit";
const user = getCurrentUser(); // e.g. "alice"

(rootDir: string, event: AuditEvent) => void

import { appendAuditEvent } from "@forge-ts/core";
const event = { timestamp: new Date().toISOString(), event: "config.lock" as const, user: "alice", reason: "Stabilize", details: {} };
appendAuditEvent("/path/to/project", event);

(rootDir: string, options?: ReadAuditOptions) => AuditEvent[]

import { readAuditLog } from "@forge-ts/core";
const events = readAuditLog("/path/to/project", { limit: 10 });
console.log(events.length); // up to 10

(event: AuditEvent) => string

import { formatAuditEvent } from "@forge-ts/core";
const event = { timestamp: "2026-03-21T12:00:00.000Z", event: "config.lock" as const, user: "alice", reason: "Stabilize", details: {} };
const line = formatAuditEvent(event);
console.log(line);

(rootDir: string, reason: string, rule?: string, config?: Partial<BypassConfig>) => BypassRecord

import { createBypass } from "@forge-ts/core";
const bypass = createBypass("/path/to/project", "hotfix for release", "E009", { dailyBudget: 5, durationHours: 12 });
console.log(bypass.id);

(rootDir: string) => BypassRecord[]

import { getActiveBypasses } from "@forge-ts/core";
const active = getActiveBypasses("/path/to/project");
console.log(`${active.length} active bypass(es)`);

(rootDir: string, ruleCode: string) => boolean

import { isRuleBypassed } from "@forge-ts/core";
if (isRuleBypassed("/path/to/project", "E009")) {
  console.log("E009 is currently bypassed");
}

(rootDir: string, config?: Partial<BypassConfig>) => number

import { getRemainingBudget } from "@forge-ts/core";
const remaining = getRemainingBudget("/path/to/project", { dailyBudget: 5, durationHours: 24 });
console.log(`${remaining} bypass(es) remaining today`);

(rootDir: string) => number

import { expireOldBypasses } from "@forge-ts/core";
const removed = expireOldBypasses("/path/to/project");
console.log(`${removed} expired bypass(es) removed`);

(config: Partial<ForgeConfig>) => Partial<ForgeConfig>

import { defineConfig } from "@forge-ts/core";

const config = { outDir: "docs", enforce: { strict: true } };
export default defineConfig(config);

(rootDir: string) => ForgeConfig

import { defaultConfig } from "@forge-ts/core";
const config = defaultConfig("/path/to/project");
console.log(config.enforce.enabled); // true

(rootDir?: string) => Promise<ForgeConfig>

import { loadConfig } from "@forge-ts/core";
const config = await loadConfig("/path/to/project");
// config is fully resolved with defaults

(rootDir: string) => ForgeLockManifest | null

import { readLockFile } from "@forge-ts/core";
const lock = readLockFile("/path/to/project");
if (lock) {
  console.log(`Locked at ${lock.lockedAt} by ${lock.lockedBy}`);
}

(rootDir: string, manifest: ForgeLockManifest) => void

import { writeLockFile, createLockManifest, loadConfig } from "@forge-ts/core";
const config = await loadConfig("/path/to/project");
const manifest = createLockManifest(config, "alice");
writeLockFile("/path/to/project", manifest);

(rootDir: string) => boolean

import { removeLockFile } from "@forge-ts/core";
const removed = removeLockFile("/path/to/project");
console.log(removed ? "Lock removed" : "No lock file found");

(config: ForgeConfig, lockedBy?: string) => ForgeLockManifest

import { createLockManifest, loadConfig } from "@forge-ts/core";
const config = await loadConfig();
const manifest = createLockManifest(config, "alice");
console.log(manifest.config.rules);

(config: ForgeConfig, lock: ForgeLockManifest) => LockViolation[]

import { validateAgainstLock, readLockFile, loadConfig } from "@forge-ts/core";
const config = await loadConfig();
const lock = readLockFile(config.rootDir);
if (lock) {
  const violations = validateAgainstLock(config, lock);
  for (const v of violations) {
    console.error(`LOCK VIOLATION: ${v.message}`);
  }
}

(tags: Record<string, string[]> | undefined) => Visibility

import { resolveVisibility } from "@forge-ts/core";
const vis = resolveVisibility({ internal: [] });
// vis === Visibility.Internal

(candidate: Visibility | "public" | "beta" | "internal" | "private", minVisibility: Visibility | "public" | "beta" | "internal" | "private") => boolean

import { meetsVisibility, Visibility } from "@forge-ts/core";
meetsVisibility(Visibility.Public, Visibility.Public); // true
meetsVisibility(Visibility.Internal, Visibility.Public); // false
meetsVisibility("public", "beta"); // true (string literals also accepted)

(symbols: ForgeSymbol[], minVisibility: Visibility | "public" | "beta" | "internal" | "private") => ForgeSymbol[]

import { filterByVisibility, Visibility } from "@forge-ts/core";
const publicOnly = filterByVisibility(symbols, Visibility.Public);

() => void

(folderPath: string) => TSDocConfiguration

(config: ForgeConfig) => ASTWalker

import { loadConfig, createWalker } from "@forge-ts/core";
const config = await loadConfig();
const walker = createWalker(config);
const symbols = walker.walk();
console.log(`Found ${symbols.length} symbols`);