phasegate 0.15.0

package/scripts/harness/biome-ast-engine/application/mappers/resolve-enabled-rules-output-mapper.ts

@@ -0,0 +1,17 @@
+/**
+ * @layer application
+ * @unit biome-ast-engine
+ */
+
+import type { RuleDefinition } from '../../domain/value-objects/rule-definition.js';
+import type { RuleName } from '../../domain/value-objects/rule-name.js';
+import type { ResolveEnabledRulesOutput } from '../dto/resolve-enabled-rules-output.js';
+
+export const toResolveEnabledRulesOutput = (
+  enabledRules: readonly RuleDefinition[],
+  skippedRules: readonly RuleName[]
+): Readonly<ResolveEnabledRulesOutput> =>
+  Object.freeze({
+    enabledRules: Object.freeze([...enabledRules]),
+    skippedRules: Object.freeze([...skippedRules]),
+  });

package/scripts/harness/biome-ast-engine/application/mappers/verify-eslint-removal-output-mapper.ts

@@ -0,0 +1,16 @@
+/**
+ * @layer application
+ * @unit biome-ast-engine
+ */
+
+import type { VerifyEslintRemovalOutput } from '../dto/verify-eslint-removal-output.js';
+
+export const toVerifyEslintRemovalOutput = (
+  configFiles: readonly string[],
+  packageDependencies: readonly string[]
+): Readonly<VerifyEslintRemovalOutput> =>
+  Object.freeze({
+    configFiles: Object.freeze([...configFiles]),
+    packageDependencies: Object.freeze([...packageDependencies]),
+    hasLegacyArtifacts: configFiles.length > 0 || packageDependencies.length > 0,
+  });

package/scripts/harness/biome-ast-engine/application/usecases/analyze-import-graph-usecase.ts

@@ -0,0 +1,41 @@
+/**
+ * @layer application
+ * @unit biome-ast-engine
+ */
+
+import type { SourceModuleAnalyzerPort } from '../../domain/ports/source-module-analyzer-port.js';
+import type { WorkspaceFilePort } from '../../domain/ports/workspace-file-port.js';
+import type { ImportGraphBuilder } from '../../domain/services/import-graph-builder.js';
+import type { AnalyzeImportGraphInput } from '../dto/analyze-import-graph-input.js';
+import type { AnalyzeImportGraphOutput } from '../dto/analyze-import-graph-output.js';
+import { toAnalyzeImportGraphOutput } from '../mappers/analyze-import-graph-output-mapper.js';
+
+type ImportGraphBuilderRunner = Pick<ImportGraphBuilder, 'build'>;
+
+export interface AnalyzeImportGraphUseCaseDeps {
+  readonly workspaceFilePort: WorkspaceFilePort;
+  readonly sourceModuleAnalyzerPort: SourceModuleAnalyzerPort;
+  readonly importGraphBuilder: ImportGraphBuilderRunner;
+}
+
+export class AnalyzeImportGraphUseCase {
+  private readonly workspaceFilePort: WorkspaceFilePort;
+  private readonly sourceModuleAnalyzerPort: SourceModuleAnalyzerPort;
+  private readonly importGraphBuilder: ImportGraphBuilderRunner;
+
+  constructor(deps: AnalyzeImportGraphUseCaseDeps) {
+    this.workspaceFilePort = deps.workspaceFilePort;
+    this.sourceModuleAnalyzerPort = deps.sourceModuleAnalyzerPort;
+    this.importGraphBuilder = deps.importGraphBuilder;
+  }
+
+  async execute(
+    input: AnalyzeImportGraphInput = {}
+  ): Promise<Readonly<AnalyzeImportGraphOutput>> {
+    const files = await this.workspaceFilePort.listSourceFiles(input.targets);
+    const snapshots = await this.sourceModuleAnalyzerPort.analyzeMany(files);
+    const importGraph = this.importGraphBuilder.build(snapshots);
+
+    return toAnalyzeImportGraphOutput(files, snapshots, importGraph);
+  }
+}

package/scripts/harness/biome-ast-engine/application/usecases/build-harness-error-payload-usecase.ts

@@ -0,0 +1,51 @@
+/**
+ * @layer application
+ * @unit biome-ast-engine
+ */
+
+import type { ViolationFormatterPort } from '../../domain/ports/violation-formatter-port.js';
+import type { BuildHarnessErrorPayloadInput } from '../dto/build-harness-error-payload-input.js';
+import type { BuildHarnessErrorPayloadOutput } from '../dto/build-harness-error-payload-output.js';
+import { toBuildHarnessErrorPayloadOutput } from '../mappers/build-harness-error-payload-output-mapper.js';
+
+export class ViolationFormattingFailedError extends Error {
+  readonly cause: unknown;
+
+  constructor(message: string, cause?: unknown) {
+    super(message);
+    this.name = 'ViolationFormattingFailedError';
+    this.cause = cause;
+  }
+}
+
+export interface BuildHarnessErrorPayloadUseCaseDeps {
+  readonly violationFormatterPort: ViolationFormatterPort;
+}
+
+export class BuildHarnessErrorPayloadUseCase {
+  private readonly violationFormatterPort: ViolationFormatterPort;
+
+  constructor(deps: BuildHarnessErrorPayloadUseCaseDeps) {
+    this.violationFormatterPort = deps.violationFormatterPort;
+  }
+
+  async execute(
+    input: BuildHarnessErrorPayloadInput
+  ): Promise<Readonly<BuildHarnessErrorPayloadOutput>> {
+    try {
+      const formattedErrors = await this.violationFormatterPort.format(input.violations);
+
+      if (formattedErrors.length !== input.violations.length) {
+        throw new ViolationFormattingFailedError('formatted error count does not match violations');
+      }
+
+      return toBuildHarnessErrorPayloadOutput(input.violations, formattedErrors);
+    } catch (error) {
+      if (error instanceof ViolationFormattingFailedError) {
+        throw error;
+      }
+
+      throw new ViolationFormattingFailedError('violation formatting failed', error);
+    }
+  }
+}

package/scripts/harness/biome-ast-engine/application/usecases/execute-lint-usecase.ts

@@ -0,0 +1,75 @@
+/**
+ * @layer application
+ * @unit biome-ast-engine
+ */
+
+import type { BiomeExecutorPort } from '../../domain/ports/biome-executor-port.js';
+import type { ClockPort } from '../../domain/ports/clock-port.js';
+import type { LintRunner } from '../../domain/services/lint-runner.js';
+import { LintReport } from '../../domain/value-objects/lint-report.js';
+import type { ExecuteLintInput } from '../dto/execute-lint-input.js';
+import type { ExecuteLintOutput } from '../dto/execute-lint-output.js';
+import { toExecuteLintOutput } from '../mappers/execute-lint-output-mapper.js';
+import type { AnalyzeImportGraphUseCase } from './analyze-import-graph-usecase.js';
+import type { ResolveEnabledRulesUseCase } from './resolve-enabled-rules-usecase.js';
+
+type ResolveEnabledRulesExecutor = Pick<ResolveEnabledRulesUseCase, 'execute'>;
+type AnalyzeImportGraphExecutor = Pick<AnalyzeImportGraphUseCase, 'execute'>;
+type LintRunnerExecutor = Pick<LintRunner, 'run'>;
+
+export interface ExecuteLintUseCaseDeps {
+  readonly resolveEnabledRulesUseCase: ResolveEnabledRulesExecutor;
+  readonly analyzeImportGraphUseCase: AnalyzeImportGraphExecutor;
+  readonly biomeExecutorPort: BiomeExecutorPort;
+  readonly lintRunner: LintRunnerExecutor;
+  readonly clockPort: ClockPort;
+}
+
+export class ExecuteLintUseCase {
+  private readonly resolveEnabledRulesUseCase: ResolveEnabledRulesExecutor;
+  private readonly analyzeImportGraphUseCase: AnalyzeImportGraphExecutor;
+  private readonly biomeExecutorPort: BiomeExecutorPort;
+  private readonly lintRunner: LintRunnerExecutor;
+  private readonly clockPort: ClockPort;
+
+  constructor(deps: ExecuteLintUseCaseDeps) {
+    this.resolveEnabledRulesUseCase = deps.resolveEnabledRulesUseCase;
+    this.analyzeImportGraphUseCase = deps.analyzeImportGraphUseCase;
+    this.biomeExecutorPort = deps.biomeExecutorPort;
+    this.lintRunner = deps.lintRunner;
+    this.clockPort = deps.clockPort;
+  }
+
+  async execute(input: ExecuteLintInput = {}): Promise<Readonly<ExecuteLintOutput>> {
+    const startedAt = this.clockPort.now();
+    const resolvedRules = await this.resolveEnabledRulesUseCase.execute();
+    const analyzed = await this.analyzeImportGraphUseCase.execute({
+      targets: input.targets,
+    });
+
+    if (input.includeBiomeNative !== false) {
+      await this.biomeExecutorPort.executeCheck(analyzed.files);
+    }
+
+    const completedAt = this.clockPort.now();
+    const durationMs = completedAt - startedAt;
+    const baseReport = this.lintRunner.run({
+      rules: resolvedRules.enabledRules,
+      snapshots: analyzed.snapshots,
+      importGraph: analyzed.importGraph,
+      durationMs,
+    });
+    const report = LintReport.create({
+      violations: baseReport.violations,
+      passedRules: baseReport.passedRules,
+      skippedRules: Object.freeze([
+        ...baseReport.skippedRules,
+        ...resolvedRules.skippedRules,
+      ]),
+      durationMs: baseReport.durationMs,
+      scannedFiles: baseReport.scannedFiles,
+    });
+
+    return toExecuteLintOutput(report, analyzed.files);
+  }
+}

package/scripts/harness/biome-ast-engine/application/usecases/register-rule-catalog-usecase.ts

@@ -0,0 +1,33 @@
+/**
+ * @layer application
+ * @unit biome-ast-engine
+ */
+
+import { UnknownRuleNameError } from '../../domain/services/rule-definition-registry.js';
+import type { RuleDefinitionRegistry } from '../../domain/services/rule-definition-registry.js';
+import type { RegisterRuleCatalogOutput } from '../dto/register-rule-catalog-output.js';
+import { toRegisterRuleCatalogOutput } from '../mappers/register-rule-catalog-output-mapper.js';
+
+type RuleDefinitionRegistryReader = Pick<RuleDefinitionRegistry, 'getAll'>;
+
+export interface RegisterRuleCatalogUseCaseDeps {
+  readonly ruleDefinitionRegistry: RuleDefinitionRegistryReader;
+}
+
+export class RegisterRuleCatalogUseCase {
+  private readonly ruleDefinitionRegistry: RuleDefinitionRegistryReader;
+
+  constructor(deps: RegisterRuleCatalogUseCaseDeps) {
+    this.ruleDefinitionRegistry = deps.ruleDefinitionRegistry;
+  }
+
+  async execute(): Promise<Readonly<RegisterRuleCatalogOutput>> {
+    const rules = this.ruleDefinitionRegistry.getAll();
+
+    if (rules.length !== 8) {
+      throw new UnknownRuleNameError(`catalog-size:${rules.length}`);
+    }
+
+    return toRegisterRuleCatalogOutput(rules);
+  }
+}

package/scripts/harness/biome-ast-engine/application/usecases/resolve-enabled-rules-usecase.ts

@@ -0,0 +1,43 @@
+/**
+ * @layer application
+ * @unit biome-ast-engine
+ */
+
+import type { RuleConfigProviderPort } from '../../domain/ports/rule-config-provider-port.js';
+import type { RuleDefinitionRegistry } from '../../domain/services/rule-definition-registry.js';
+import type { ResolveEnabledRulesInput } from '../dto/resolve-enabled-rules-input.js';
+import type { ResolveEnabledRulesOutput } from '../dto/resolve-enabled-rules-output.js';
+import { toResolveEnabledRulesOutput } from '../mappers/resolve-enabled-rules-output-mapper.js';
+
+type RuleDefinitionResolver = Pick<RuleDefinitionRegistry, 'resolveEnabled'>;
+
+export interface ResolveEnabledRulesUseCaseDeps {
+  readonly ruleConfigProviderPort: RuleConfigProviderPort;
+  readonly ruleDefinitionRegistry: RuleDefinitionResolver;
+}
+
+export class ResolveEnabledRulesUseCase {
+  private readonly ruleConfigProviderPort: RuleConfigProviderPort;
+  private readonly ruleDefinitionRegistry: RuleDefinitionResolver;
+
+  constructor(deps: ResolveEnabledRulesUseCaseDeps) {
+    this.ruleConfigProviderPort = deps.ruleConfigProviderPort;
+    this.ruleDefinitionRegistry = deps.ruleDefinitionRegistry;
+  }
+
+  async execute(
+    input: ResolveEnabledRulesInput = {}
+  ): Promise<Readonly<ResolveEnabledRulesOutput>> {
+    const config = await this.ruleConfigProviderPort.getL1Config();
+    const mergedRules = {
+      ...config.rules,
+      ...(input.overrideRules ?? {}),
+    };
+    const resolved = this.ruleDefinitionRegistry.resolveEnabled({
+      l1Enabled: config.enabled,
+      rules: mergedRules,
+    });
+
+    return toResolveEnabledRulesOutput(resolved.enabledRules, resolved.skippedRules);
+  }
+}

package/scripts/harness/biome-ast-engine/application/usecases/verify-eslint-removal-usecase.ts

@@ -0,0 +1,49 @@
+/**
+ * @layer application
+ * @unit biome-ast-engine
+ */
+
+import type { WorkspaceInventoryPort } from '../../domain/ports/workspace-inventory-port.js';
+import type { VerifyEslintRemovalInput } from '../dto/verify-eslint-removal-input.js';
+import type { VerifyEslintRemovalOutput } from '../dto/verify-eslint-removal-output.js';
+import { toVerifyEslintRemovalOutput } from '../mappers/verify-eslint-removal-output-mapper.js';
+
+export class LegacyEslintArtifactDetectedError extends Error {
+  readonly configFiles: readonly string[];
+  readonly packageDependencies: readonly string[];
+
+  constructor(output: VerifyEslintRemovalOutput) {
+    super('legacy eslint artifacts detected');
+    this.name = 'LegacyEslintArtifactDetectedError';
+    this.configFiles = output.configFiles;
+    this.packageDependencies = output.packageDependencies;
+  }
+}
+
+export interface VerifyEslintRemovalUseCaseDeps {
+  readonly workspaceInventoryPort: WorkspaceInventoryPort;
+}
+
+export class VerifyEslintRemovalUseCase {
+  private readonly workspaceInventoryPort: WorkspaceInventoryPort;
+
+  constructor(deps: VerifyEslintRemovalUseCaseDeps) {
+    this.workspaceInventoryPort = deps.workspaceInventoryPort;
+  }
+
+  async execute(
+    input: VerifyEslintRemovalInput = {}
+  ): Promise<Readonly<VerifyEslintRemovalOutput>> {
+    const artifacts = await this.workspaceInventoryPort.findLegacyEslintArtifacts();
+    const output = toVerifyEslintRemovalOutput(
+      artifacts.configFiles,
+      artifacts.packageDependencies
+    );
+
+    if (input.failOnLegacyArtifacts === true && output.hasLegacyArtifacts) {
+      throw new LegacyEslintArtifactDetectedError(output);
+    }
+
+    return output;
+  }
+}

package/scripts/harness/biome-ast-engine/composition-root.ts

@@ -0,0 +1,91 @@
+/**
+ * @layer composition
+ * @unit biome-ast-engine
+ *
+ * biome-ast-engine ユニットの Composition Root。
+ * 全コンポーネントを生成・配線し、外部に公開するハンドラーを返す。
+ */
+
+// Infrastructure adapters
+import { SystemClockAdapter } from './infrastructure/adapters/system-clock-adapter.js';
+import { HarnessConfigProviderAdapter, type L1ConfigInput } from './infrastructure/adapters/harness-config-provider-adapter.js';
+import { HarnessErrorFormatterAdapter } from './infrastructure/adapters/harness-error-formatter-adapter.js';
+import { NodeWorkspaceFileAdapter } from './infrastructure/adapters/node-workspace-file-adapter.js';
+import { TypeScriptSourceModuleAnalyzerAdapter } from './infrastructure/adapters/typescript-source-module-analyzer-adapter.js';
+import { BiomeCliExecutorAdapter } from './infrastructure/adapters/biome-cli-executor-adapter.js';
+import { WorkspaceInventoryAdapter } from './infrastructure/adapters/workspace-inventory-adapter.js';
+
+// Domain services
+import { RuleDefinitionRegistry } from './domain/services/rule-definition-registry.js';
+import { ImportGraphBuilder } from './domain/services/import-graph-builder.js';
+import { LintRunner } from './domain/services/lint-runner.js';
+
+// Usecases
+import { ResolveEnabledRulesUseCase } from './application/usecases/resolve-enabled-rules-usecase.js';
+import { AnalyzeImportGraphUseCase } from './application/usecases/analyze-import-graph-usecase.js';
+import { ExecuteLintUseCase } from './application/usecases/execute-lint-usecase.js';
+import { VerifyEslintRemovalUseCase } from './application/usecases/verify-eslint-removal-usecase.js';
+import { BuildHarnessErrorPayloadUseCase } from './application/usecases/build-harness-error-payload-usecase.js';
+
+// Presentation
+import { HarnessLintCommandHandler } from './presentation/cli/harness-lint-command-handler.js';
+
+export interface BiomeAstEngineModuleOptions {
+  readonly l1Config?: L1ConfigInput;
+}
+
+export function createBiomeAstEngineModule(
+  rootDir: string,
+  options?: BiomeAstEngineModuleOptions,
+) {
+  // Infrastructure
+  const clockPort = new SystemClockAdapter();
+  const ruleConfigProviderPort = new HarnessConfigProviderAdapter(options?.l1Config);
+  const violationFormatterPort = new HarnessErrorFormatterAdapter();
+  const workspaceFilePort = new NodeWorkspaceFileAdapter({ rootDir });
+  const sourceModuleAnalyzerPort = new TypeScriptSourceModuleAnalyzerAdapter({ rootDir });
+  const biomeExecutorPort = new BiomeCliExecutorAdapter({ cwd: rootDir });
+  const workspaceInventoryPort = new WorkspaceInventoryAdapter({ rootDir });
+
+  // Domain services
+  const ruleDefinitionRegistry = new RuleDefinitionRegistry();
+  const importGraphBuilder = new ImportGraphBuilder();
+  const lintRunner = new LintRunner(ruleDefinitionRegistry);
+
+  // Usecases
+  const resolveEnabledRulesUseCase = new ResolveEnabledRulesUseCase({
+    ruleConfigProviderPort,
+    ruleDefinitionRegistry,
+  });
+
+  const analyzeImportGraphUseCase = new AnalyzeImportGraphUseCase({
+    workspaceFilePort,
+    sourceModuleAnalyzerPort,
+    importGraphBuilder,
+  });
+
+  const executeLintUseCase = new ExecuteLintUseCase({
+    resolveEnabledRulesUseCase,
+    analyzeImportGraphUseCase,
+    biomeExecutorPort,
+    lintRunner,
+    clockPort,
+  });
+
+  const verifyEslintRemovalUseCase = new VerifyEslintRemovalUseCase({
+    workspaceInventoryPort,
+  });
+
+  const buildHarnessErrorPayloadUseCase = new BuildHarnessErrorPayloadUseCase({
+    violationFormatterPort,
+  });
+
+  // Presentation handler
+  const harnessLintCommandHandler = new HarnessLintCommandHandler({
+    executeLintUseCase,
+    verifyEslintRemovalUseCase,
+    buildHarnessErrorPayloadUseCase,
+  });
+
+  return { harnessLintCommandHandler, executeLintUseCase } as const;
+}

package/scripts/harness/biome-ast-engine/domain/ports/biome-executor-port.ts

@@ -0,0 +1,10 @@
+/**
+ * @layer domain
+ * @unit biome-ast-engine
+ */
+
+import { FilePath } from '../value-objects/file-path.js';
+
+export interface BiomeExecutorPort {
+  executeCheck(files: readonly FilePath[]): Promise<void>;
+}

package/scripts/harness/biome-ast-engine/domain/ports/clock-port.ts

@@ -0,0 +1,8 @@
+/**
+ * @layer domain
+ * @unit biome-ast-engine
+ */
+
+export interface ClockPort {
+  now(): number;
+}

package/scripts/harness/biome-ast-engine/domain/ports/rule-config-provider-port.ts

@@ -0,0 +1,11 @@
+/**
+ * @layer domain
+ * @unit biome-ast-engine
+ */
+
+export interface RuleConfigProviderPort {
+  getL1Config(): Promise<{
+    enabled: boolean;
+    rules: Record<string, 'error' | 'warning' | 'off'>;
+  }>;
+}

package/scripts/harness/biome-ast-engine/domain/ports/source-module-analyzer-port.ts

@@ -0,0 +1,11 @@
+/**
+ * @layer domain
+ * @unit biome-ast-engine
+ */
+
+import { FilePath } from '../value-objects/file-path.js';
+import { SourceModuleSnapshot } from '../value-objects/source-module-snapshot.js';
+
+export interface SourceModuleAnalyzerPort {
+  analyzeMany(files: readonly FilePath[]): Promise<readonly SourceModuleSnapshot[]>;
+}

package/scripts/harness/biome-ast-engine/domain/ports/violation-formatter-port.ts

@@ -0,0 +1,19 @@
+/**
+ * @layer domain
+ * @unit biome-ast-engine
+ */
+
+import { RuleViolation } from '../value-objects/rule-violation.js';
+
+export interface ViolationFormatterPort {
+  format(violations: readonly RuleViolation[]): Promise<
+    readonly {
+      code: string;
+      severity: 'error' | 'warning';
+      message: string;
+      suggestion: string;
+      adr_ref?: string;
+      fix_example?: string;
+    }[]
+  >;
+}

package/scripts/harness/biome-ast-engine/domain/ports/workspace-file-port.ts

@@ -0,0 +1,12 @@
+/**
+ * @layer domain
+ * @unit biome-ast-engine
+ */
+
+import { FilePath } from '../value-objects/file-path.js';
+
+export interface WorkspaceFilePort {
+  listSourceFiles(targets?: readonly string[]): Promise<readonly FilePath[]>;
+  readText(filePath: FilePath): Promise<string>;
+  exists(filePath: FilePath): Promise<boolean>;
+}

package/scripts/harness/biome-ast-engine/domain/ports/workspace-inventory-port.ts

@@ -0,0 +1,11 @@
+/**
+ * @layer domain
+ * @unit biome-ast-engine
+ */
+
+export interface WorkspaceInventoryPort {
+  findLegacyEslintArtifacts(): Promise<{
+    configFiles: readonly string[];
+    packageDependencies: readonly string[];
+  }>;
+}

package/scripts/harness/biome-ast-engine/domain/services/import-graph-builder.ts

@@ -0,0 +1,37 @@
+/**
+ * @layer domain
+ * @unit biome-ast-engine
+ */
+
+import { ImportGraph } from '../value-objects/import-graph.js';
+import { SourceModuleSnapshot } from '../value-objects/source-module-snapshot.js';
+
+export class ImportGraphBuilder {
+  build(snapshots: readonly SourceModuleSnapshot[]): ImportGraph {
+    const nodes = Object.freeze(snapshots.map((snapshot) => snapshot.filePath));
+    const nodeSet = new Set(nodes.map((node) => node.toString()));
+    const edges = Object.freeze(
+      snapshots
+        .flatMap((snapshot) => snapshot.imports)
+        .filter(
+          (edge) => nodeSet.has(edge.from.toString()) && nodeSet.has(edge.to.toString())
+        )
+    );
+    const rootNodes = Object.freeze(
+      snapshots
+        .filter((snapshot) => {
+          const filePath = snapshot.filePath.toString();
+          return (
+            snapshot.isEntrypointCandidate ||
+            filePath.endsWith('/index.ts') ||
+            filePath === 'index.ts' ||
+            filePath.includes('/presentation/cli/') ||
+            filePath.startsWith('presentation/cli/')
+          );
+        })
+        .map((snapshot) => snapshot.filePath)
+    );
+
+    return ImportGraph.create({ nodes, edges, rootNodes });
+  }
+}