@ontrails/warden 1.0.0-beta.3 → 1.0.0-beta.32

package/src/trails/wrap-rule.ts

@@ -0,0 +1,214 @@
+/**
+ * Factory that wraps a WardenRule as a trail.
+ *
+ * Keeps each rule trail file minimal — just the import + examples.
+ */
+
+import { InternalError, trail, Result } from '@ontrails/core';
+import type { Trail } from '@ontrails/core';
+
+import type {
+  ProjectAwareWardenRule,
+  ProjectContext,
+  TopoAwareWardenRule,
+  WardenRule,
+} from '../rules/types.js';
+import { getWardenRuleMetadata } from '../rules/metadata.js';
+import {
+  projectAwareRuleInput,
+  ruleInput,
+  ruleOutput,
+  topoAwareRuleInput,
+} from './schema.js';
+import type {
+  ProjectAwareRuleInput,
+  RuleInput,
+  RuleOutput,
+  TopoAwareRuleInput,
+} from './schema.js';
+
+interface WrapRuleOptions {
+  /** The existing warden rule to wrap. */
+  readonly rule: WardenRule;
+  /** Trail examples for testing and documentation. */
+  readonly examples: Trail<RuleInput, RuleOutput>['examples'];
+}
+
+interface WrapProjectAwareRuleOptions {
+  /** The existing project-aware warden rule to wrap. */
+  readonly rule: ProjectAwareWardenRule;
+  /** Trail examples for testing and documentation. */
+  readonly examples: Trail<ProjectAwareRuleInput, RuleOutput>['examples'];
+}
+
+const buildRuleMeta = (rule: WardenRule | TopoAwareWardenRule) => {
+  const metadata = getWardenRuleMetadata(rule);
+  return {
+    category: 'governance',
+    ...(metadata ? { warden: metadata } : {}),
+    severity: rule.severity,
+  };
+};
+
+const buildProjectContext = (input: ProjectAwareRuleInput): ProjectContext => ({
+  ...(input.contourReferencesByName
+    ? {
+        contourReferencesByName: new Map(
+          Object.entries(input.contourReferencesByName)
+        ),
+      }
+    : {}),
+  ...(input.crudTableIds ? { crudTableIds: new Set(input.crudTableIds) } : {}),
+  ...(input.crudCoverageByEntity
+    ? {
+        crudCoverageByEntity: new Map(
+          Object.entries(input.crudCoverageByEntity).map(
+            ([entityId, operations]) => [
+              entityId,
+              new Set(operations) as ReadonlySet<string>,
+            ]
+          )
+        ),
+      }
+    : {}),
+  ...(input.knownContourIds
+    ? { knownContourIds: new Set(input.knownContourIds) }
+    : {}),
+  ...(input.importResolutionsByFile
+    ? {
+        importResolutionsByFile: new Map(
+          Object.entries(input.importResolutionsByFile)
+        ),
+      }
+    : {}),
+  ...(input.documentedImportResolutionsByFile
+    ? {
+        documentedImportResolutionsByFile: new Map(
+          Object.entries(input.documentedImportResolutionsByFile)
+        ),
+      }
+    : {}),
+  ...(input.publicWorkspaces
+    ? { publicWorkspaces: new Map(Object.entries(input.publicWorkspaces)) }
+    : {}),
+  knownTrailIds: input.knownTrailIds
+    ? new Set(input.knownTrailIds)
+    : new Set<string>(),
+  ...(input.composeTargetTrailIds
+    ? { composeTargetTrailIds: new Set(input.composeTargetTrailIds) }
+    : {}),
+  ...(input.knownResourceIds
+    ? { knownResourceIds: new Set(input.knownResourceIds) }
+    : {}),
+  ...(input.knownSignalIds
+    ? { knownSignalIds: new Set(input.knownSignalIds) }
+    : {}),
+  ...(input.onTargetSignalIds
+    ? { onTargetSignalIds: new Set(input.onTargetSignalIds) }
+    : {}),
+  ...(input.reconcileTableIds
+    ? { reconcileTableIds: new Set(input.reconcileTableIds) }
+    : {}),
+  ...(input.trailIntentsById
+    ? { trailIntentsById: new Map(Object.entries(input.trailIntentsById)) }
+    : {}),
+  ...(input.topoTrailIds ? { topoTrailIds: new Set(input.topoTrailIds) } : {}),
+});
+
+/**
+ * Wrap an existing `WardenRule` as a trail with typed input/output.
+ *
+ * The trail ID follows the pattern `warden.rule.<rule-name>`.
+ */
+export function wrapRule(
+  options: WrapProjectAwareRuleOptions
+): Trail<ProjectAwareRuleInput, RuleOutput>;
+export function wrapRule(
+  options: WrapRuleOptions
+): Trail<RuleInput, RuleOutput>;
+export function wrapRule(
+  options: WrapRuleOptions | WrapProjectAwareRuleOptions
+): Trail<RuleInput, RuleOutput> | Trail<ProjectAwareRuleInput, RuleOutput> {
+  const { rule, examples } = options;
+  const isProjectAware = 'checkWithContext' in rule;
+
+  if (isProjectAware) {
+    const projectAwareRule = rule as ProjectAwareWardenRule;
+    return trail(`warden.rule.${rule.name}`, {
+      blaze: (input: ProjectAwareRuleInput) => {
+        const diagnostics = projectAwareRule.checkWithContext(
+          input.sourceCode,
+          input.filePath,
+          buildProjectContext(input)
+        );
+        return Result.ok({ diagnostics: [...diagnostics] });
+      },
+      description: rule.description,
+      examples: examples as Trail<
+        ProjectAwareRuleInput,
+        RuleOutput
+      >['examples'],
+      input: projectAwareRuleInput,
+      intent: 'read',
+      meta: buildRuleMeta(rule),
+      output: ruleOutput,
+    });
+  }
+
+  return trail(`warden.rule.${rule.name}`, {
+    blaze: (input: RuleInput) => {
+      const diagnostics = rule.check(input.sourceCode, input.filePath);
+      return Result.ok({ diagnostics: [...diagnostics] });
+    },
+    description: rule.description,
+    examples: examples as Trail<RuleInput, RuleOutput>['examples'],
+    input: ruleInput,
+    intent: 'read',
+    meta: buildRuleMeta(rule),
+    output: ruleOutput,
+  });
+}
+
+interface WrapTopoRuleOptions {
+  /** The existing topo-aware warden rule to wrap. */
+  readonly rule: TopoAwareWardenRule;
+  /** Trail examples for testing and documentation. */
+  readonly examples: Trail<TopoAwareRuleInput, RuleOutput>['examples'];
+}
+
+/**
+ * Wrap an existing `TopoAwareWardenRule` as a trail.
+ *
+ * Mirrors `wrapRule` for the per-topo dispatch path. Topo-aware rules run
+ * once per topo against the compiled runtime graph rather than per file,
+ * so the trail accepts the live `Topo` as input.
+ */
+export const wrapTopoRule = (
+  options: WrapTopoRuleOptions
+): Trail<TopoAwareRuleInput, RuleOutput> => {
+  const { rule, examples } = options;
+  return trail(`warden.rule.${rule.name}`, {
+    blaze: async (input: TopoAwareRuleInput) => {
+      try {
+        const diagnostics = await rule.checkTopo(input.topo, {
+          graph: input.graph,
+        });
+        return Result.ok({ diagnostics: [...diagnostics] });
+      } catch (error) {
+        const cause = error instanceof Error ? error : new Error(String(error));
+        return Result.err(
+          new InternalError(
+            `Topo-aware rule "${rule.name}" threw while inspecting topo: ${cause.message}`,
+            { cause }
+          )
+        );
+      }
+    },
+    description: rule.description,
+    examples,
+    input: topoAwareRuleInput,
+    intent: 'read',
+    meta: buildRuleMeta(rule),
+    output: ruleOutput,
+  });
+};

package/src/workspaces.ts

@@ -0,0 +1,199 @@
+/**
+ * Workspace-manifest discovery for Warden project-aware rules.
+ */
+
+import { realpathSync } from 'node:fs';
+import { dirname, join, relative, resolve } from 'node:path';
+
+import { listWorkspacePackages, matchesAnyPathGlob } from '@ontrails/core';
+
+export interface WardenPublicWorkspace {
+  readonly name: string;
+  readonly rootDir: string;
+  readonly packageJsonPath: string;
+  readonly hasExports: boolean;
+  readonly bin?: Readonly<Record<string, string>> | undefined;
+  readonly exportTargets?: Readonly<Record<string, string>> | undefined;
+  readonly files?: readonly string[] | undefined;
+}
+
+export interface WardenWorkspaceCollectionOptions {
+  readonly exclude?: readonly string[];
+}
+
+interface PackageManifest {
+  readonly bin?: unknown;
+  readonly exports?: unknown;
+  readonly files?: unknown;
+  readonly name?: unknown;
+  readonly private?: unknown;
+}
+
+const normalizePath = (path: string): string => path.replaceAll('\\', '/');
+
+const normalizeRealPath = (path: string): string => {
+  try {
+    return normalizePath(realpathSync(path));
+  } catch {
+    return normalizePath(resolve(path));
+  }
+};
+
+const rootRelativePath = (rootDir: string, path: string): string =>
+  normalizePath(relative(rootDir, path));
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  Boolean(value && typeof value === 'object' && !Array.isArray(value));
+
+const packageLocalName = (name: string): string =>
+  name.split('/').at(-1) ?? name;
+
+const normalizeBin = (
+  name: string,
+  value: unknown
+): Readonly<Record<string, string>> | undefined => {
+  if (typeof value === 'string') {
+    return { [packageLocalName(name)]: value };
+  }
+  if (!isRecord(value)) {
+    return undefined;
+  }
+
+  const entries = Object.entries(value).filter(
+    (entry): entry is [string, string] => typeof entry[1] === 'string'
+  );
+  return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+};
+
+const normalizeFiles = (value: unknown): readonly string[] | undefined => {
+  if (!Array.isArray(value)) {
+    return undefined;
+  }
+
+  const files = value.filter(
+    (entry): entry is string => typeof entry === 'string'
+  );
+  return files.length > 0 ? files : undefined;
+};
+
+const resolveExportTarget = (
+  target: unknown,
+  depth = 0
+): string | undefined => {
+  if (typeof target === 'string') {
+    return target;
+  }
+  if (!isRecord(target) || depth > 8) {
+    return undefined;
+  }
+
+  for (const condition of ['bun', 'import', 'default', 'require'] as const) {
+    const conditionalTarget = target[condition];
+    const resolvedTarget = resolveExportTarget(conditionalTarget, depth + 1);
+    if (resolvedTarget) {
+      return resolvedTarget;
+    }
+  }
+  return undefined;
+};
+
+const exportSpecifierFromKey = (
+  packageName: string,
+  key: string
+): string | undefined => {
+  if (key === '.') {
+    return packageName;
+  }
+  if (!key.startsWith('./') || key.includes('*')) {
+    return undefined;
+  }
+  return `${packageName}/${key.slice(2)}`;
+};
+
+const normalizeExportTargets = (
+  packageDir: string,
+  packageName: string,
+  exportsValue: unknown
+): Readonly<Record<string, string>> | undefined => {
+  if (!isRecord(exportsValue)) {
+    return undefined;
+  }
+
+  const targets: Record<string, string> = {};
+  for (const [key, value] of Object.entries(exportsValue)) {
+    const specifier = exportSpecifierFromKey(packageName, key);
+    const target = resolveExportTarget(value);
+    if (!specifier || !target) {
+      continue;
+    }
+    targets[specifier] = normalizeRealPath(join(packageDir, target));
+  }
+
+  return Object.keys(targets).length > 0 ? targets : undefined;
+};
+
+const publicWorkspaceFromManifest = (
+  packageJsonPath: string,
+  manifest: PackageManifest
+): WardenPublicWorkspace | undefined => {
+  if (typeof manifest.name !== 'string') {
+    return undefined;
+  }
+  if (!manifest.name.startsWith('@ontrails/')) {
+    return undefined;
+  }
+  if (manifest.private === true) {
+    return undefined;
+  }
+
+  const packageDir = dirname(packageJsonPath);
+  const bin = normalizeBin(manifest.name, manifest.bin);
+  const exportTargets = normalizeExportTargets(
+    packageDir,
+    manifest.name,
+    manifest.exports
+  );
+  const files = normalizeFiles(manifest.files);
+
+  return {
+    ...(bin ? { bin } : {}),
+    ...(exportTargets ? { exportTargets } : {}),
+    ...(files ? { files } : {}),
+    hasExports: manifest.exports !== undefined,
+    name: manifest.name,
+    packageJsonPath: normalizeRealPath(packageJsonPath),
+    rootDir: normalizeRealPath(dirname(packageJsonPath)),
+  };
+};
+
+export const collectPublicWorkspaces = (
+  rootDir: string,
+  options: WardenWorkspaceCollectionOptions = {}
+): ReadonlyMap<string, WardenPublicWorkspace> => {
+  const normalizedRoot = normalizeRealPath(rootDir);
+  const workspaces = new Map<string, WardenPublicWorkspace>();
+
+  for (const workspacePackage of listWorkspacePackages<PackageManifest>(
+    normalizedRoot
+  )) {
+    const workspace = publicWorkspaceFromManifest(
+      workspacePackage.packageJsonPath,
+      workspacePackage.manifest
+    );
+    if (
+      workspace &&
+      !matchesAnyPathGlob(
+        rootRelativePath(normalizedRoot, workspace.rootDir),
+        options.exclude ?? []
+      ) &&
+      !matchesAnyPathGlob(
+        rootRelativePath(normalizedRoot, workspace.packageJsonPath),
+        options.exclude ?? []
+      )
+    ) {
+      workspaces.set(workspace.name, workspace);
+    }
+  }
+
+  return workspaces;
+};

package/.turbo/turbo-build.log

@@ -1 +0,0 @@
-$ tsc -b

package/.turbo/turbo-lint.log

@@ -1,3 +0,0 @@
-$ oxlint ./src
-Found 0 warnings and 0 errors.
-Finished in 46ms on 30 files with 93 rules using 24 threads.

package/.turbo/turbo-typecheck.log

@@ -1 +0,0 @@
-$ tsc --noEmit

package/dist/cli.d.ts

@@ -1,46 +0,0 @@
-/**
- * Warden CLI command runner.
- *
- * Scans TypeScript files, runs all warden rules, optionally checks drift,
- * and returns a structured report.
- */
-import type { Topo } from '@ontrails/core';
-import type { DriftResult } from './drift.js';
-import type { WardenDiagnostic } from './rules/types.js';
-/**
- * Options for the warden CLI runner.
- */
-export interface WardenOptions {
-    /** Root directory to scan for TypeScript files. Defaults to cwd. */
-    readonly rootDir?: string | undefined;
-    /** Only run lint rules, skip drift detection */
-    readonly lintOnly?: boolean | undefined;
-    /** Only run drift detection, skip lint rules */
-    readonly driftOnly?: boolean | undefined;
-    /** App topology for drift detection. When provided, enables real surface lock comparison. */
-    readonly topo?: Topo | undefined;
-}
-/**
- * Result of a warden run.
- */
-export interface WardenReport {
-    /** All diagnostics from lint rules */
-    readonly diagnostics: readonly WardenDiagnostic[];
-    /** Count of error-severity diagnostics */
-    readonly errorCount: number;
-    /** Count of warn-severity diagnostics */
-    readonly warnCount: number;
-    /** Drift detection result, or null if skipped */
-    readonly drift: DriftResult | null;
-    /** Whether the warden run passed (no errors, no drift) */
-    readonly passed: boolean;
-}
-/**
- * Run all warden checks and return a structured report.
- */
-export declare const runWarden: (options?: WardenOptions) => Promise<WardenReport>;
-/**
- * Format a warden report as a human-readable string.
- */
-export declare const formatWardenReport: (report: WardenReport) => string;
-//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAE3C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAS9C,OAAO,KAAK,EAGV,gBAAgB,EAEjB,MAAM,kBAAkB,CAAC;AAE1B;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,oEAAoE;IACpE,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC,gDAAgD;IAChD,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACxC,gDAAgD;IAChD,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACzC,6FAA6F;IAC7F,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,GAAG,SAAS,CAAC;CAClC;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,sCAAsC;IACtC,QAAQ,CAAC,WAAW,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAClD,0CAA0C;IAC1C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,yCAAyC;IACzC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,iDAAiD;IACjD,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI,CAAC;IACnC,0DAA0D;IAC1D,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;CAC1B;AAyLD;;GAEG;AACH,eAAO,MAAM,SAAS,GACpB,UAAS,aAAkB,KAC1B,OAAO,CAAC,YAAY,CAqBtB,CAAC;AAsDF;;GAEG;AACH,eAAO,MAAM,kBAAkB,GAAI,QAAQ,YAAY,KAAG,MAmBzD,CAAC"}

package/dist/cli.js

@@ -1,221 +0,0 @@
-/**
- * Warden CLI command runner.
- *
- * Scans TypeScript files, runs all warden rules, optionally checks drift,
- * and returns a structured report.
- */
-import { resolve } from 'node:path';
-import { checkDrift } from './drift.js';
-import { findConfigProperty, findTrailDefinitions, parse, walk, } from './rules/ast.js';
-import { wardenRules } from './rules/index.js';
-/**
- * Collect all .ts files under a directory, excluding node_modules, dist, and .git.
- */
-const isSourceFile = (match) => !match.endsWith('.d.ts') &&
-    !match.startsWith('node_modules/') &&
-    !match.startsWith('dist/') &&
-    !match.startsWith('.git/') &&
-    !match.includes('__tests__/') &&
-    !match.includes('__test__/') &&
-    !match.endsWith('.test.ts') &&
-    !match.endsWith('.spec.ts');
-const collectTsFiles = (dir) => {
-    const glob = new Bun.Glob('**/*.ts');
-    let matches;
-    try {
-        matches = glob.scanSync({ cwd: dir, dot: false, onlyFiles: true });
-    }
-    catch {
-        return [];
-    }
-    const files = [];
-    for (const match of matches) {
-        if (isSourceFile(match)) {
-            files.push(`${dir}/${match}`);
-        }
-    }
-    return files;
-};
-const collectKnownTrailIds = (sourceCode, filePath, knownTrailIds) => {
-    const ast = parse(filePath, sourceCode);
-    if (!ast) {
-        return;
-    }
-    for (const def of findTrailDefinitions(ast)) {
-        knownTrailIds.add(def.id);
-    }
-};
-const collectDetourTargetTrailIds = (sourceCode, filePath, detourTargetTrailIds) => {
-    const ast = parse(filePath, sourceCode);
-    if (!ast) {
-        return;
-    }
-    for (const def of findTrailDefinitions(ast)) {
-        const detoursProp = findConfigProperty(def.config, 'detours');
-        if (!detoursProp) {
-            continue;
-        }
-        // Walk the detours value for string literals that look like trail IDs
-        walk(detoursProp, (node) => {
-            if (node.type !== 'Literal') {
-                return;
-            }
-            const val = node.value;
-            if (val && val.includes('.')) {
-                detourTargetTrailIds.add(val);
-            }
-        });
-    }
-};
-const loadSourceFiles = async (rootDir) => {
-    const sourceFiles = [];
-    for (const filePath of collectTsFiles(rootDir)) {
-        try {
-            sourceFiles.push({
-                filePath,
-                sourceCode: await Bun.file(filePath).text(),
-            });
-        }
-        catch {
-            continue;
-        }
-    }
-    return sourceFiles;
-};
-const buildProjectContextFromTopo = (appTopo) => {
-    const knownTrailIds = new Set([
-        ...appTopo.trails.keys(),
-        ...appTopo.hikes.keys(),
-    ]);
-    const detourTargetTrailIds = new Set();
-    for (const t of [...appTopo.trails.values(), ...appTopo.hikes.values()]) {
-        const detours = t['detours'];
-        if (!detours) {
-            continue;
-        }
-        for (const targets of Object.values(detours)) {
-            for (const id of targets) {
-                detourTargetTrailIds.add(id);
-            }
-        }
-    }
-    return { detourTargetTrailIds, knownTrailIds };
-};
-const buildProjectContextFromFiles = (sourceFiles) => {
-    const knownTrailIds = new Set();
-    const detourTargetTrailIds = new Set();
-    for (const sourceFile of sourceFiles) {
-        collectKnownTrailIds(sourceFile.sourceCode, sourceFile.filePath, knownTrailIds);
-        collectDetourTargetTrailIds(sourceFile.sourceCode, sourceFile.filePath, detourTargetTrailIds);
-    }
-    return {
-        detourTargetTrailIds,
-        knownTrailIds,
-    };
-};
-const isProjectAwareRule = (rule) => 'checkWithContext' in rule;
-/**
- * Lint all files against all warden rules.
- */
-const lintFiles = async (rootDir, appTopo) => {
-    const allDiagnostics = [];
-    const sourceFiles = await loadSourceFiles(rootDir);
-    const context = appTopo
-        ? buildProjectContextFromTopo(appTopo)
-        : buildProjectContextFromFiles(sourceFiles);
-    for (const sourceFile of sourceFiles) {
-        for (const rule of wardenRules.values()) {
-            if (isProjectAwareRule(rule)) {
-                allDiagnostics.push(...rule.checkWithContext(sourceFile.sourceCode, sourceFile.filePath, context));
-                continue;
-            }
-            allDiagnostics.push(...rule.check(sourceFile.sourceCode, sourceFile.filePath));
-        }
-    }
-    return allDiagnostics;
-};
-/**
- * Run all warden checks and return a structured report.
- */
-export const runWarden = async (options = {}) => {
-    const rootDir = resolve(options.rootDir ?? process.cwd());
-    const allDiagnostics = options.driftOnly
-        ? []
-        : await lintFiles(rootDir, options.topo);
-    const drift = options.lintOnly
-        ? null
-        : await checkDrift(rootDir, options.topo);
-    const errorCount = allDiagnostics.filter((d) => d.severity === 'error').length;
-    const warnCount = allDiagnostics.filter((d) => d.severity === 'warn').length;
-    return {
-        diagnostics: allDiagnostics,
-        drift,
-        errorCount,
-        passed: errorCount === 0 && !(drift?.stale ?? false),
-        warnCount,
-    };
-};
-/**
- * Format the lint section of the report.
- */
-const formatLintSection = (report) => {
-    if (report.diagnostics.length === 0) {
-        return ['Lint: clean'];
-    }
-    const lines = [
-        `Lint: ${report.errorCount} errors, ${report.warnCount} warnings`,
-    ];
-    for (const d of report.diagnostics) {
-        const prefix = d.severity === 'error' ? 'ERROR' : 'WARN';
-        lines.push(`  ${d.filePath}:${String(d.line)}  [${prefix}] ${d.rule}  ${d.message}`);
-    }
-    return lines;
-};
-/**
- * Format the drift section of the report.
- */
-const formatDriftSection = (drift) => {
-    if (drift === null) {
-        return [];
-    }
-    const label = drift.stale
-        ? 'Drift: surface.lock is stale (regenerate with `trails survey generate`)'
-        : 'Drift: clean';
-    return [label, ''];
-};
-/**
- * Format the result line.
- */
-const formatResultLine = (report) => {
-    if (report.passed) {
-        return 'Result: PASS';
-    }
-    const parts = [];
-    if (report.errorCount > 0) {
-        parts.push(`${report.errorCount} errors`);
-    }
-    if (report.drift?.stale) {
-        parts.push('drift detected');
-    }
-    return `Result: FAIL (${parts.join(', ')})`;
-};
-/**
- * Format a warden report as a human-readable string.
- */
-export const formatWardenReport = (report) => {
-    const lintLines = formatLintSection(report);
-    const driftLines = formatDriftSection(report.drift);
-    if (lintLines.length === 0 && driftLines.length === 0) {
-        return ['Warden Report', '=============', '', 'No checks were run.'].join('\n');
-    }
-    return [
-        'Warden Report',
-        '=============',
-        '',
-        ...lintLines,
-        '',
-        ...driftLines,
-        formatResultLine(report),
-    ].join('\n');
-};
-//# sourceMappingURL=cli.js.map