@ankhorage/doctor 0.11.96 → 0.12.0

package/src/cliLayoutAnalysis.ts

@@ -1,7 +1,7 @@
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
 
-import { ARCHITECTURE_POLICY } from '@ankhorage/policy/architecture';
+import { REPOSITORY_RULE_IDS, REPOSITORY_RULE_METADATA } from '@ankhorage/rules-repository';
 
 import {
   analyzeDoctorTarget,
@@ -10,11 +10,12 @@ import {
 } from './analysis.js';
 import type { DoctorDiagnostic, DoctorPolicyProfile } from './diagnostics.js';
 import { analyzeAppManifestTarget } from './manifestAnalysis.js';
+import { analyzeRepositorySourceRules } from './repositorySourceRulesAnalysis.js';
 import { analyzeSourceArchitecture } from './sourceArchitectureAnalysis.js';
-import { getArchitecturePolicyRule } from './utils/getArchitecturePolicyRule.js';
+import { getRepositoryRule } from './utils/getRepositoryRule.js';
 
-const CLI_POLICY = ARCHITECTURE_POLICY.cli;
-const DEPENDENCY_POLICY = ARCHITECTURE_POLICY.dependencies;
+const CLI_POLICY = REPOSITORY_RULE_METADATA.cli;
+const DEPENDENCY_POLICY = REPOSITORY_RULE_METADATA.dependencies;
 const ACTIVE_SOURCE_ROOTS = ['src', 'app', 'apps', 'packages', 'scripts'] as const;
 const ACTIVE_SOURCE_EXTENSIONS = new Set([
   '.cjs',
@@ -119,7 +120,7 @@ async function analyzeTargetArchitecture(request: {
       message: 'Package CLI code must live under src/cli/; root src/cli.ts is not allowed.',
       path: legacyRootCliPath,
       profile: request.profile,
-      ...architectureRuleFields(CLI_POLICY.legacyRootRuleId),
+      ...repositoryRuleFields(REPOSITORY_RULE_IDS.cliRootFile),
     });
   }
 
@@ -130,7 +131,7 @@ async function analyzeTargetArchitecture(request: {
         'CLI-capable packages must export "./cli" from package.json and point it at the metadata-declared provider build output.',
       path: request.packageJsonPath,
       profile: request.profile,
-      ...architectureRuleFields(CLI_POLICY.exportRuleId),
+      ...repositoryRuleFields(REPOSITORY_RULE_IDS.cliExport),
     });
   }
 
@@ -143,16 +144,23 @@ async function analyzeTargetArchitecture(request: {
     }),
   );
 
-  const activeSourceImports = await collectActiveSourceImports(request.targetPath);
+  const activeSource = await collectActiveSourceSnapshot(request.targetPath);
   diagnostics.push(
     ...validateActiveSourceImports({
-      activeSourceImports,
+      activeSourceImports: activeSource.imports,
       profile: request.profile,
     }),
   );
+  diagnostics.push(
+    ...analyzeRepositorySourceRules({
+      files: activeSource.files,
+      imports: activeSource.imports,
+      profile: request.profile,
+      targetPath: request.targetPath,
+    }),
+  );
   diagnostics.push(
     ...(await analyzeSourceArchitecture({
-      activeSourceImports,
       profile: request.profile,
       targetPath: request.targetPath,
     })),
@@ -161,7 +169,7 @@ async function analyzeTargetArchitecture(request: {
   if (request.packageJson.name === STUDIO_PACKAGE_NAME) {
     diagnostics.push(
       ...validateStudioOwnership({
-        activeSourceImports,
+        activeSourceImports: activeSource.imports,
         dependencyEntries,
         packageJsonPath: request.packageJsonPath,
         profile: request.profile,
@@ -186,7 +194,7 @@ function validateDependencyArchitecture(request: {
         message: `Dependency "${dependency.packageName}" in package.json.${dependency.fieldName} is an old ankhorage4 workspace alias. Depend on "${toOwningPackageSpecifier(dependency.packageName)}" directly.`,
         path: request.packageJsonPath,
         profile: request.profile,
-        ...architectureRuleFields(DEPENDENCY_POLICY.rules.compatibilityDependency),
+        ...repositoryRuleFields(REPOSITORY_RULE_IDS.compatibilityDependency),
       });
     }
 
@@ -201,7 +209,7 @@ function validateDependencyArchitecture(request: {
         message: `Published dependency "${dependency.packageName}" must resolve from a registry version, not "${dependency.version}". Standalone packages cannot rely on local/workspace/Git package state.`,
         path: request.packageJsonPath,
         profile: request.profile,
-        ...architectureRuleFields(DEPENDENCY_POLICY.rules.localProtocolDependency),
+        ...repositoryRuleFields(REPOSITORY_RULE_IDS.localProtocolDependency),
       });
     }
 
@@ -214,7 +222,7 @@ function validateDependencyArchitecture(request: {
         message: `Dependency "${dependency.packageName}" references ankhorage4 as active source. Depend on the extracted owning @ankhorage/* package instead.`,
         path: request.packageJsonPath,
         profile: request.profile,
-        ...architectureRuleFields(DEPENDENCY_POLICY.rules.legacySourceDependency),
+        ...repositoryRuleFields(REPOSITORY_RULE_IDS.legacySourceDependency),
       });
     }
   }
@@ -235,7 +243,7 @@ function validateActiveSourceImports(request: {
         message: `Import "${sourceImport.specifier}" is an old ankhorage4 compatibility boundary. Import "${toOwningPackageSpecifier(sourceImport.specifier)}" directly from the owning package.`,
         path: sourceImport.filePath,
         profile: request.profile,
-        ...architectureRuleFields(DEPENDENCY_POLICY.rules.compatibilityImport),
+        ...repositoryRuleFields(REPOSITORY_RULE_IDS.compatibilityImport),
       });
     }
 
@@ -245,7 +253,7 @@ function validateActiveSourceImports(request: {
         message: `Import "${sourceImport.specifier}" references ankhorage4 as active source. Import the extracted owning @ankhorage/* package instead.`,
         path: sourceImport.filePath,
         profile: request.profile,
-        ...architectureRuleFields(DEPENDENCY_POLICY.rules.legacySourceImport),
+        ...repositoryRuleFields(REPOSITORY_RULE_IDS.legacySourceImport),
       });
     }
   }
@@ -320,24 +328,37 @@ function validateStudioOwnership(request: {
   return diagnostics;
 }
 
-async function collectActiveSourceImports(targetPath: string): Promise<ActiveSourceImport[]> {
-  const imports: ActiveSourceImport[] = [];
+interface ActiveSourceSnapshot {
+  readonly files: readonly string[];
+  readonly imports: readonly ActiveSourceImport[];
+}
+
+/***
+ * Collects active production files and their static import specifiers once for repository checks.
+ */
+async function collectActiveSourceSnapshot(targetPath: string): Promise<ActiveSourceSnapshot> {
+  const files: string[] = [];
 
   for (const sourceRoot of ACTIVE_SOURCE_ROOTS) {
     const sourceRootPath = path.join(targetPath, sourceRoot);
-    if (!(await pathExists(sourceRootPath))) {
-      continue;
-    }
-
-    for (const filePath of await listActiveSourceFiles(sourceRootPath)) {
-      const source = await fs.readFile(filePath, 'utf8');
-      for (const specifier of extractImportSpecifiers(source)) {
-        imports.push({ filePath, specifier });
-      }
+    if (await pathExists(sourceRootPath)) {
+      files.push(...(await listActiveSourceFiles(sourceRootPath)));
     }
   }
 
-  return imports;
+  const imports = (
+    await Promise.all(
+      files.map(async (filePath) => {
+        const source = await fs.readFile(filePath, 'utf8');
+        return extractImportSpecifiers(source).map((specifier) => ({ filePath, specifier }));
+      }),
+    )
+  ).flat();
+
+  return {
+    files: [...files].sort((left, right) => left.localeCompare(right)),
+    imports,
+  };
 }
 
 async function listActiveSourceFiles(rootPath: string): Promise<string[]> {
@@ -428,11 +449,11 @@ function isPackageImport(specifier: string, packageName: string): boolean {
   return specifier === packageName || specifier.startsWith(`${packageName}/`);
 }
 
-/*** Resolve Policy-owned rule metadata for generic architecture diagnostics. */
-function architectureRuleFields(
+/*** Resolve repository Rules metadata for package and source-boundary diagnostics. */
+function repositoryRuleFields(
   ruleId: DoctorDiagnostic['ruleId'],
 ): Pick<DoctorDiagnostic, 'ruleId' | 'severity'> {
-  const rule = getArchitecturePolicyRule(ruleId);
+  const rule = getRepositoryRule(ruleId);
   return { ruleId: rule.id, severity: rule.severity };
 }
 

package/src/repositorySourceRulesAnalysis.ts

@@ -0,0 +1,153 @@
+import path from 'node:path';
+
+import {
+  evaluateRepository,
+  REPOSITORY_RULE_IDS,
+  type RepositoryImportFact,
+  type RepositoryPathFact,
+} from '@ankhorage/rules-repository';
+
+import type {
+  DoctorDiagnostic,
+  DoctorDiagnosticSeverity,
+  DoctorPolicyProfile,
+  DoctorRuleId,
+} from './diagnostics.js';
+
+const ENABLED_REPOSITORY_SOURCE_RULES = [
+  REPOSITORY_RULE_IDS.catchAllDirectory,
+  REPOSITORY_RULE_IDS.importOutsideRoot,
+] as const satisfies readonly DoctorRuleId[];
+
+interface RepositorySourceRulesInput {
+  readonly files: readonly string[];
+  readonly imports: readonly {
+    readonly filePath: string;
+    readonly specifier: string;
+  }[];
+  readonly profile: DoctorPolicyProfile;
+  readonly targetPath: string;
+}
+
+/***
+ * Evaluates repository-owned source rules from Doctor's normalized active-source snapshot.
+ */
+export function analyzeRepositorySourceRules(
+  input: RepositorySourceRulesInput,
+): readonly DoctorDiagnostic[] {
+  const result = evaluateRepository(
+    {
+      cliCommands: [],
+      imports: input.imports.map((sourceImport) => toImportFact(input.targetPath, sourceImport)),
+      packageJson: {
+        dependencies: [],
+        exports: [],
+        fields: {},
+        scripts: {},
+      },
+      paths: collectDirectoryFacts(input.targetPath, input.files),
+      workflowBunVersions: {},
+    },
+    {
+      config: {
+        version: 1,
+        rules: ENABLED_REPOSITORY_SOURCE_RULES.map((id) => ({ enabled: true, id })),
+      },
+    },
+  );
+
+  return result.findings.map((finding) => toDoctorDiagnostic(input, finding));
+}
+
+/***
+ * Converts one active source import into portable repository-boundary evidence.
+ */
+function toImportFact(
+  targetPath: string,
+  sourceImport: RepositorySourceRulesInput['imports'][number],
+): RepositoryImportFact {
+  return {
+    path: toPortableRelativePath(targetPath, sourceImport.filePath),
+    specifier: sourceImport.specifier,
+    ...(sourceImport.specifier.startsWith('.')
+      ? { escapesRepositoryRoot: importEscapesRepository(targetPath, sourceImport) }
+      : {}),
+  };
+}
+
+/***
+ * Determines whether one relative source import resolves outside the standalone repository root.
+ */
+function importEscapesRepository(
+  targetPath: string,
+  sourceImport: RepositorySourceRulesInput['imports'][number],
+): boolean {
+  const resolvedTarget = path.resolve(path.dirname(sourceImport.filePath), sourceImport.specifier);
+  const relativeTarget = path.relative(targetPath, resolvedTarget);
+  return relativeTarget.startsWith('..') || path.isAbsolute(relativeTarget);
+}
+
+/***
+ * Derives unique directory facts from active production source files.
+ */
+function collectDirectoryFacts(
+  targetPath: string,
+  files: readonly string[],
+): readonly RepositoryPathFact[] {
+  const directories = new Set<string>();
+
+  for (const filePath of files) {
+    const segments = toPortableRelativePath(targetPath, filePath).split('/').filter(Boolean);
+    for (let index = 1; index < segments.length; index += 1) {
+      directories.add(segments.slice(0, index).join('/'));
+    }
+  }
+
+  return [...directories]
+    .sort((left, right) => left.localeCompare(right))
+    .map((directoryPath) => ({ kind: 'directory' as const, path: directoryPath }));
+}
+
+/***
+ * Converts one repository path into stable forward-slash relative form.
+ */
+function toPortableRelativePath(targetPath: string, filePath: string): string {
+  return path.relative(targetPath, filePath).split(path.sep).join('/');
+}
+
+/***
+ * Converts one repository Rule finding into Doctor's stable diagnostic surface.
+ */
+function toDoctorDiagnostic(
+  input: RepositorySourceRulesInput,
+  finding: ReturnType<typeof evaluateRepository>['findings'][number],
+): DoctorDiagnostic {
+  const subjectPath = finding.sourceLocation?.path ?? finding.subjects[0]?.path ?? '.';
+  return {
+    code: 'field-invalid',
+    message: finding.message,
+    path: path.resolve(input.targetPath, subjectPath),
+    profile: input.profile,
+    ruleId: toDoctorRuleId(finding.ruleId),
+    severity: toDoctorSeverity(finding.severity),
+  };
+}
+
+/***
+ * Narrows repository-provider ids to the source rules Doctor intentionally evaluates here.
+ */
+function toDoctorRuleId(ruleId: string): DoctorRuleId {
+  const match = ENABLED_REPOSITORY_SOURCE_RULES.find((candidate) => candidate === ruleId);
+  if (match === undefined) throw new Error('Unexpected Doctor repository source rule: ' + ruleId);
+  return match;
+}
+
+/***
+ * Narrows generic Rules severity to Doctor's diagnostic severity surface.
+ */
+function toDoctorSeverity(severity: 'error' | 'info' | 'warning'): DoctorDiagnosticSeverity {
+  if (severity === 'info') {
+    throw new Error('Doctor does not support info-level repository diagnostics.');
+  }
+  return severity;
+}

package/src/sourceArchitectureAnalysis.ts

@@ -1,205 +1,130 @@
-import { promises as fs } from 'node:fs';
 import path from 'node:path';
 
-import { ARCHITECTURE_POLICY } from '@ankhorage/policy/architecture';
-
-import type { DoctorDiagnostic, DoctorPolicyProfile } from './diagnostics.js';
-import { getArchitecturePolicyRule } from './utils/getArchitecturePolicyRule.js';
-
-interface SourceImport {
-  readonly filePath: string;
-  readonly specifier: string;
-}
+import { createSourceGraphAsync, type SourceGraph } from '@ankhorage/dependency-graph';
+import { evaluateArchitectureProfile } from '@ankhorage/rules-architecture';
+
+import type {
+  DoctorDiagnostic,
+  DoctorDiagnosticSeverity,
+  DoctorPolicyProfile,
+  DoctorRuleId,
+} from './diagnostics.js';
+
+const ENABLED_ARCHITECTURE_RULES = [
+  'package.architecture.domain-outward-import.disallowed',
+  'package.architecture.application-outward-import.disallowed',
+  'package.architecture.port-outward-import.disallowed',
+  'package.architecture.delivery-concrete-adapter-import.disallowed',
+] as const satisfies readonly DoctorRuleId[];
+
+const ACTIVE_SOURCE_ROOTS = ['src', 'app', 'apps', 'packages', 'scripts'] as const;
+const IGNORED_SOURCE_DIRECTORIES = new Set([
+  '.expo',
+  '.git',
+  '.next',
+  '__fixtures__',
+  '__tests__',
+  'build',
+  'coverage',
+  'dist',
+  'docs',
+  'fixtures',
+  'node_modules',
+  'paradox',
+  'test',
+  'tests',
+]);
 
 interface AnalyzeSourceArchitectureInput {
-  readonly activeSourceImports: readonly SourceImport[];
   readonly profile: DoctorPolicyProfile;
   readonly targetPath: string;
 }
 
-const SOURCE_POLICY = ARCHITECTURE_POLICY.source;
-
-/*** Validate folder-role combinations and inward source dependency direction. */
+/***
+ * Evaluates Doctor's currently enforced source-architecture subset through rules-architecture.
+ */
 export async function analyzeSourceArchitecture(
   input: AnalyzeSourceArchitectureInput,
 ): Promise<DoctorDiagnostic[]> {
-  return [...(await analyzeDirectoryVocabularyAsync(input)), ...analyzeImportDirection(input)];
-}
-
-/*** Validate architectural directory names only when a repository has introduced them. */
-async function analyzeDirectoryVocabularyAsync(
-  input: AnalyzeSourceArchitectureInput,
-): Promise<DoctorDiagnostic[]> {
-  const diagnostics: DoctorDiagnostic[] = [];
-  const sourceRoot = path.join(input.targetPath, 'src');
-
-  for (const directoryName of SOURCE_POLICY.catchAllDirectories) {
-    const directoryPath = path.join(sourceRoot, directoryName);
-    if (await pathExistsAsync(directoryPath)) {
-      diagnostics.push(
-        createDiagnostic(
-          input,
-          directoryPath,
-          ARCHITECTURE_POLICY.rules.catchAllDirectory,
-          `src/${directoryName}/ is a generic catch-all. Move code to an owning domain, feature, package edge, or utils/ according to the repository profile.`,
-        ),
-      );
-    }
-  }
-
-  // Folder-role combination enforcement stays deferred until rules-architecture is canonical.
-  return diagnostics;
-}
-
-/*** Validate that relative source imports point inward across recognized architecture roles. */
-function analyzeImportDirection(input: AnalyzeSourceArchitectureInput): DoctorDiagnostic[] {
-  return input.activeSourceImports.flatMap((sourceImport) =>
-    analyzeOneImportDirection(input, sourceImport),
-  );
-}
-
-/*** Validate one relative import against repository and layer boundaries. */
-function analyzeOneImportDirection(
-  input: AnalyzeSourceArchitectureInput,
-  sourceImport: SourceImport,
-): DoctorDiagnostic[] {
-  if (!sourceImport.specifier.startsWith('.')) return [];
-
-  const targetPath = path.resolve(path.dirname(sourceImport.filePath), sourceImport.specifier);
-  const escaped = createEscapedRepositoryDiagnostic(input, sourceImport, targetPath);
-  if (escaped !== null) return [escaped];
-
-  return analyzeRecognizedRoleDirection(input, sourceImport, targetPath);
-}
-
-/*** Report a relative import that escapes the standalone repository boundary. */
-function createEscapedRepositoryDiagnostic(
-  input: AnalyzeSourceArchitectureInput,
-  sourceImport: SourceImport,
-  targetPath: string,
-): DoctorDiagnostic | null {
-  const relativeTarget = path.relative(input.targetPath, targetPath);
-  if (!relativeTarget.startsWith('..') && !path.isAbsolute(relativeTarget)) return null;
-
-  return createDiagnostic(
-    input,
-    sourceImport.filePath,
-    getArchitecturePolicyRule(SOURCE_POLICY.repositoryBoundaryRuleId),
-    `Relative import "${sourceImport.specifier}" escapes the standalone repository root.`,
-  );
+  const graph = await createSourceGraphAsync({
+    projects: [{ id: 'doctor-target', rootPath: input.targetPath }],
+  });
+  const result = evaluateArchitectureProfile(filterActiveSourceGraph(graph), 'ankhorage', {
+    config: {
+      version: 1,
+      rules: ENABLED_ARCHITECTURE_RULES.map((id) => ({ enabled: true, id })),
+    },
+  });
+
+  return result.findings.map((finding) => toDoctorDiagnostic(input, finding));
 }
 
-/*** Apply inward dependency rules for recognized source architecture roles. */
-function analyzeRecognizedRoleDirection(
-  input: AnalyzeSourceArchitectureInput,
-  sourceImport: SourceImport,
-  targetPath: string,
-): DoctorDiagnostic[] {
-  const sourceSegments = splitRelativePath(input.targetPath, sourceImport.filePath);
-  const targetSegments = splitRelativePath(input.targetPath, targetPath);
-  const deliveryPolicy = SOURCE_POLICY.thinDeliveryAdapter;
-
-  if (
-    includesSegmentSequence(sourceSegments, deliveryPolicy.pathSegments) &&
-    targetSegments.includes(deliveryPolicy.concreteAdapterSegment)
-  ) {
-    return [
-      createDiagnostic(
-        input,
-        sourceImport.filePath,
-        getArchitecturePolicyRule(deliveryPolicy.ruleId),
-        `Thin delivery adapter must not wire concrete adapter implementation through "${sourceImport.specifier}". Import an application operation or composition boundary instead.`,
-      ),
-    ];
-  }
-
-  const role = resolveSourceRole(sourceSegments);
-  if (role === null) return [];
-
-  return createOutwardImportDiagnostic(input, sourceImport, targetSegments, role);
+/***
+ * Keeps architecture evaluation aligned with Doctor's existing active-source scan contract.
+ */
+function filterActiveSourceGraph(graph: SourceGraph): SourceGraph {
+  const nodeById = new Map(graph.graph.nodes.map((node) => [node.id, node.data]));
+  return {
+    ...graph,
+    graph: {
+      nodes: graph.graph.nodes,
+      edges: graph.graph.edges.filter((edge) => {
+        if (edge.data.kind !== 'imports') return true;
+        const source = nodeById.get(edge.source);
+        const sourcePath = source?.path ?? source?.filePath;
+        return sourcePath === undefined || isActiveSourcePath(sourcePath);
+      }),
+    },
+  };
 }
 
-/*** Resolve the dependency rule owned by one recognized inner source role. */
-function resolveSourceRole(sourceSegments: readonly string[]): SourceRoleRule | null {
-  for (const role of Object.values(SOURCE_POLICY.roles)) {
-    if (
-      sourceSegments.some((segment) => role.segments.some((roleSegment) => roleSegment === segment))
-    ) {
-      return {
-        forbiddenSegments: new Set<string>(role.forbiddenOutwardSegments),
-        label: role.label,
-        rule: getArchitecturePolicyRule(role.ruleId),
-      };
-    }
+/***
+ * Checks whether one portable path belongs to Doctor's active production-source surface.
+ */
+function isActiveSourcePath(sourcePath: string): boolean {
+  const normalized = sourcePath.split(path.sep).join('/');
+  const [root, ...segments] = normalized.split('/').filter(Boolean);
+  if (root === undefined || !ACTIVE_SOURCE_ROOTS.some((candidate) => candidate === root)) {
+    return false;
   }
-
-  return null;
-}
-
-interface SourceRoleRule {
-  readonly forbiddenSegments: ReadonlySet<string>;
-  readonly label: string;
-  readonly rule: ReturnType<typeof getArchitecturePolicyRule>;
+  if (segments.some((segment) => IGNORED_SOURCE_DIRECTORIES.has(segment))) return false;
+  const fileName = segments.at(-1) ?? '';
+  return !/(?:^|\.)(?:spec|test)\.[cm]?[jt]sx?$/u.test(fileName);
 }
 
-/*** Report one outward dependency when the imported path crosses a forbidden role. */
-function createOutwardImportDiagnostic(
+/***
+ * Converts one architecture Rule finding into Doctor's stable diagnostic surface.
+ */
+function toDoctorDiagnostic(
   input: AnalyzeSourceArchitectureInput,
-  sourceImport: SourceImport,
-  targetSegments: readonly string[],
-  role: SourceRoleRule,
-): DoctorDiagnostic[] {
-  const outwardRole = targetSegments.find((segment) => role.forbiddenSegments.has(segment));
-  if (outwardRole === undefined) return [];
-
-  return [
-    createDiagnostic(
-      input,
-      sourceImport.filePath,
-      role.rule,
-      `${role.label} must not import outward ${outwardRole}/ implementation through "${sourceImport.specifier}".`,
-    ),
-  ];
-}
-
-/*** Check whether one path segment sequence occurs contiguously in another. */
-function includesSegmentSequence(
-  segments: readonly string[],
-  expected: readonly string[],
-): boolean {
-  return segments.some((_, index) =>
-    expected.every((segment, offset) => segments[index + offset] === segment),
-  );
-}
-
-/*** Split one repository path into normalized architecture segments. */
-function splitRelativePath(targetPath: string, filePath: string): readonly string[] {
-  return path.relative(targetPath, filePath).split(path.sep).filter(Boolean);
-}
-
-/*** Build one deterministic architecture diagnostic from Policy-owned metadata. */
-function createDiagnostic(
-  input: AnalyzeSourceArchitectureInput,
-  diagnosticPath: string,
-  rule: ReturnType<typeof getArchitecturePolicyRule>,
-  message: string,
+  finding: ReturnType<typeof evaluateArchitectureProfile>['findings'][number],
 ): DoctorDiagnostic {
+  const subjectPath = finding.sourceLocation?.path ?? finding.subjects[0]?.path ?? '.';
   return {
     code: 'field-invalid',
-    message,
-    path: diagnosticPath,
+    message: finding.message,
+    path: path.resolve(input.targetPath, subjectPath),
     profile: input.profile,
-    ruleId: rule.id,
-    severity: rule.severity,
+    ruleId: toDoctorRuleId(finding.ruleId),
+    severity: toDoctorSeverity(finding.severity),
   };
 }
 
-/*** Check whether a filesystem path exists. */
-async function pathExistsAsync(targetPath: string): Promise<boolean> {
-  try {
-    await fs.access(targetPath);
-    return true;
-  } catch {
-    return false;
+/***
+ * Narrows architecture-provider rule ids to the subset Doctor intentionally enforces.
+ */
+function toDoctorRuleId(ruleId: string): DoctorRuleId {
+  const match = ENABLED_ARCHITECTURE_RULES.find((candidate) => candidate === ruleId);
+  if (match === undefined) throw new Error('Unexpected Doctor architecture rule: ' + ruleId);
+  return match;
+}
+
+/***
+ * Narrows generic Rules severity to Doctor's diagnostic severity surface.
+ */
+function toDoctorSeverity(severity: 'error' | 'info' | 'warning'): DoctorDiagnosticSeverity {
+  if (severity === 'info') {
+    throw new Error('Doctor does not support info-level architecture diagnostics.');
   }
+  return severity;
 }

package/src/utils/getRepositoryRule.ts

@@ -0,0 +1,20 @@
+import { createRepositoryRuleSet } from '@ankhorage/rules-repository';
+
+import type { DoctorDiagnosticSeverity, DoctorRuleId } from '../diagnostics.js';
+
+/***
+ * Resolves one canonical repository rule by its stable Doctor rule id.
+ */
+export function getRepositoryRule(ruleId: DoctorRuleId): {
+  readonly id: DoctorRuleId;
+  readonly severity: DoctorDiagnosticSeverity;
+} {
+  const rule = createRepositoryRuleSet().rules.find((candidate) => candidate.id === ruleId);
+  if (rule === undefined) {
+    throw new Error('Unknown repository rule: ' + ruleId);
+  }
+  if (rule.defaultSeverity === 'info') {
+    throw new Error('Doctor does not support info-level repository diagnostics: ' + ruleId);
+  }
+  return { id: ruleId, severity: rule.defaultSeverity };
+}