phasegate 0.15.0

package/scripts/harness/quick-mode/application/usecases/build-relaxation-profile-usecase.ts

@@ -0,0 +1,76 @@
+/**
+ * @layer application
+ * @unit quick-mode
+ *
+ * H10-02: eligible=trueが確定した場合にValidatorRelaxationProfileを生成して返すUseCase
+ */
+
+import { ValidatorRelaxationService } from '../../domain/services/validator-relaxation-service.js';
+import { QuickModeConfig } from '../../domain/value-objects/quick-mode-config.js';
+import { QuickModeDecisionContractMapper } from '../mappers/quick-mode-decision-contract-mapper.js';
+import type { QuickModeConfigPort } from '../ports/quick-mode-config-port.js';
+import type { ValidatorIdRegistryPort } from '../ports/validator-id-registry-port.js';
+import type { QuickModeEligibilityContract } from '../dto/quick-mode-eligibility-contract.js';
+import type { ValidatorRelaxationProfileContract } from '../dto/validator-relaxation-profile-contract.js';
+
+export class QuickModeNotEligibleError extends Error {
+  constructor() {
+    super('Cannot build relaxation profile: Quick Mode is not eligible');
+    this.name = 'QuickModeNotEligibleError';
+  }
+}
+
+export interface BuildRelaxationProfileUseCaseInput {
+  readonly eligibilityContract: QuickModeEligibilityContract;
+}
+
+// IT テストでの eligibility キー名にも対応
+export interface BuildRelaxationProfileUseCaseInputAlt {
+  readonly eligibility: QuickModeEligibilityContract;
+}
+
+export interface BuildRelaxationProfileUseCaseDeps {
+  quickModeConfigPort: QuickModeConfigPort;
+  validatorIdRegistryPort: ValidatorIdRegistryPort;
+  relaxationService?: ValidatorRelaxationService;
+}
+
+export class BuildRelaxationProfileUseCase {
+  private readonly quickModeConfigPort: QuickModeConfigPort;
+  private readonly validatorIdRegistryPort: ValidatorIdRegistryPort;
+  private readonly relaxationService: ValidatorRelaxationService;
+  private readonly mapper: QuickModeDecisionContractMapper;
+
+  constructor(deps: BuildRelaxationProfileUseCaseDeps) {
+    this.quickModeConfigPort = deps.quickModeConfigPort;
+    this.validatorIdRegistryPort = deps.validatorIdRegistryPort;
+    this.relaxationService = deps.relaxationService ?? new ValidatorRelaxationService();
+    this.mapper = new QuickModeDecisionContractMapper();
+  }
+
+  async execute(
+    input: BuildRelaxationProfileUseCaseInput | BuildRelaxationProfileUseCaseInputAlt
+  ): Promise<Readonly<ValidatorRelaxationProfileContract>> {
+    // eligibilityContract または eligibility キーに対応
+    const eligibilityContract =
+      'eligibilityContract' in input ? input.eligibilityContract : input.eligibility;
+
+    // 1. eligible=false の場合は早期エラー
+    if (!eligibilityContract.eligible) {
+      throw new QuickModeNotEligibleError();
+    }
+
+    // 2. 設定の取得
+    const config = await this.quickModeConfigPort.getConfig();
+
+    // 3. 全 ValidatorId の取得
+    const allValidatorIds = await this.validatorIdRegistryPort.getAllIds();
+
+    // 4. 緩和プロファイルの生成
+    const profile = this.relaxationService.build(config, allValidatorIds);
+
+    // 5. DTO に変換して返す（再帰的 freeze）
+    const contract = this.mapper.toRelaxationProfileContract(profile);
+    return Object.freeze(contract);
+  }
+}

package/scripts/harness/quick-mode/application/usecases/execute-quick-ci-check-usecase.ts

@@ -0,0 +1,63 @@
+/**
+ * @layer application
+ * @unit quick-mode
+ *
+ * H10-03: harness:ci-check --quick の実行フロー全体を調停するUseCase
+ */
+
+import type { JudgeQuickModeEligibilityUseCase } from './judge-quick-mode-eligibility-usecase.js';
+import type { BuildRelaxationProfileUseCase } from './build-relaxation-profile-usecase.js';
+import type { ValidatorExecutionPort } from '../ports/validator-execution-port.js';
+import type { QuickModeDecisionContract } from '../dto/quick-mode-decision-contract.js';
+
+export interface ExecuteQuickCiCheckUseCaseInput {
+  readonly changedFiles?: readonly { filePath: string; changeKind: string }[];
+  readonly dryRun?: boolean;
+}
+
+export interface ExecuteQuickCiCheckUseCaseDeps {
+  judgeUseCase: Pick<JudgeQuickModeEligibilityUseCase, 'execute'>;
+  buildUseCase: Pick<BuildRelaxationProfileUseCase, 'execute'>;
+  validatorExecutionPort?: ValidatorExecutionPort;
+}
+
+export class ExecuteQuickCiCheckUseCase {
+  private readonly judgeUseCase: Pick<JudgeQuickModeEligibilityUseCase, 'execute'>;
+  private readonly buildUseCase: Pick<BuildRelaxationProfileUseCase, 'execute'>;
+  private readonly validatorExecutionPort: ValidatorExecutionPort | undefined;
+
+  constructor(deps: ExecuteQuickCiCheckUseCaseDeps) {
+    this.judgeUseCase = deps.judgeUseCase;
+    this.buildUseCase = deps.buildUseCase;
+    this.validatorExecutionPort = deps.validatorExecutionPort;
+  }
+
+  async execute(input: ExecuteQuickCiCheckUseCaseInput): Promise<Readonly<QuickModeDecisionContract>> {
+    const { changedFiles, dryRun = false } = input;
+
+    // 1. H10-01: 適用可否判定
+    const eligibility = await this.judgeUseCase.execute({ changedFiles });
+
+    // 2. eligible=false の場合は早期リターン
+    if (!eligibility.eligible) {
+      return Object.freeze({
+        eligibility,
+        relaxationProfile: undefined,
+      });
+    }
+
+    // 3. H10-02: 緩和プロファイル生成
+    const relaxationProfile = await this.buildUseCase.execute({ eligibilityContract: eligibility });
+
+    // 4. dryRun=false の場合は validator-system に緩和プロファイルを渡す
+    if (!dryRun && this.validatorExecutionPort) {
+      await this.validatorExecutionPort.executeWithProfile(relaxationProfile);
+    }
+
+    // 5. 統合 DTO を返す
+    return Object.freeze({
+      eligibility,
+      relaxationProfile,
+    });
+  }
+}

package/scripts/harness/quick-mode/application/usecases/judge-quick-mode-eligibility-usecase.ts

@@ -0,0 +1,57 @@
+/**
+ * @layer application
+ * @unit quick-mode
+ *
+ * H10-01: ChangedFile[]を受け取り、Quick Mode適用可否を判定してQuickModeEligibilityContractを返すUseCase
+ */
+
+import { ChangedFile } from '../../domain/value-objects/changed-file.js';
+import { QuickModeJudgmentEngine } from '../../domain/services/quick-mode-judgment-engine.js';
+import { QuickModeDecisionContractMapper } from '../mappers/quick-mode-decision-contract-mapper.js';
+import type { ChangedFilesPort } from '../ports/changed-files-port.js';
+import type { QuickModeConfigPort } from '../ports/quick-mode-config-port.js';
+import type { QuickModeEligibilityContract } from '../dto/quick-mode-eligibility-contract.js';
+
+export interface JudgeQuickModeEligibilityUseCaseInput {
+  readonly changedFiles?: readonly { filePath: string; changeKind: string }[];
+}
+
+export interface JudgeQuickModeEligibilityUseCaseDeps {
+  changedFilesPort: ChangedFilesPort;
+  quickModeConfigPort: QuickModeConfigPort;
+  judgmentEngine?: QuickModeJudgmentEngine;
+}
+
+export class JudgeQuickModeEligibilityUseCase {
+  private readonly changedFilesPort: ChangedFilesPort;
+  private readonly quickModeConfigPort: QuickModeConfigPort;
+  private readonly judgmentEngine: QuickModeJudgmentEngine;
+  private readonly mapper: QuickModeDecisionContractMapper;
+
+  constructor(deps: JudgeQuickModeEligibilityUseCaseDeps) {
+    this.changedFilesPort = deps.changedFilesPort;
+    this.quickModeConfigPort = deps.quickModeConfigPort;
+    this.judgmentEngine = deps.judgmentEngine ?? new QuickModeJudgmentEngine();
+    this.mapper = new QuickModeDecisionContractMapper();
+  }
+
+  async execute(input: JudgeQuickModeEligibilityUseCaseInput): Promise<Readonly<QuickModeEligibilityContract>> {
+    // 1. 変更ファイルの取得
+    let changedFiles: readonly ChangedFile[];
+
+    if (input.changedFiles !== undefined) {
+      changedFiles = input.changedFiles.map((f) => ChangedFile.create(f));
+    } else {
+      changedFiles = await this.changedFilesPort.getChangedFiles();
+    }
+
+    // 2. 設定の取得
+    const config = await this.quickModeConfigPort.getConfig();
+
+    // 3. 判定の実行
+    const eligibility = this.judgmentEngine.judge(changedFiles, config);
+
+    // 4. DTO に変換して返す
+    return Object.freeze(this.mapper.toEligibilityContract(eligibility));
+  }
+}

package/scripts/harness/quick-mode/composition-root.ts

@@ -0,0 +1,74 @@
+/**
+ * @layer application
+ * @unit quick-mode
+ *
+ * quick-mode ユニットの Composition Root
+ */
+
+import { GitDiffChangedFilesAdapter } from './infrastructure/adapters/git-diff-changed-files-adapter.js';
+import { HarnessConfigQuickModeConfigAdapter } from './infrastructure/adapters/harness-config-quick-mode-config-adapter.js';
+import { ValidatorSystemValidatorIdRegistryAdapter } from './infrastructure/adapters/validator-system-validator-id-registry-adapter.js';
+import { QuickModeJudgmentEngine } from './domain/services/quick-mode-judgment-engine.js';
+import { ValidatorRelaxationService } from './domain/services/validator-relaxation-service.js';
+import { QuickModeDecisionContractMapper } from './application/mappers/quick-mode-decision-contract-mapper.js';
+import { JudgeQuickModeEligibilityUseCase } from './application/usecases/judge-quick-mode-eligibility-usecase.js';
+import { BuildRelaxationProfileUseCase } from './application/usecases/build-relaxation-profile-usecase.js';
+import { ExecuteQuickCiCheckUseCase } from './application/usecases/execute-quick-ci-check-usecase.js';
+import { CiCheckQuickModeHandler } from './presentation/handlers/ci-check-quick-mode-handler.js';
+
+export interface QuickModeCompositionRoot {
+  handler: CiCheckQuickModeHandler;
+  executeUseCase: ExecuteQuickCiCheckUseCase;
+  judgeUseCase: JudgeQuickModeEligibilityUseCase;
+  buildUseCase: BuildRelaxationProfileUseCase;
+}
+
+export function createQuickModeCompositionRoot(): QuickModeCompositionRoot {
+  // Infrastructure
+  const gitDiffAdapter = new GitDiffChangedFilesAdapter();
+  const harnessConfigAdapter = new HarnessConfigQuickModeConfigAdapter();
+  const validatorIdRegistryAdapter = new ValidatorSystemValidatorIdRegistryAdapter();
+
+  // Domain Services
+  const judgmentEngine = new QuickModeJudgmentEngine();
+  const relaxationService = new ValidatorRelaxationService();
+
+  // Application - wrap infra adapters to match application port interface
+  const changedFilesPort = {
+    getChangedFiles: () => Promise.resolve(gitDiffAdapter.getChangedFiles()),
+  };
+  const quickModeConfigPort = {
+    getConfig: () => harnessConfigAdapter.getQuickModeConfig(),
+  };
+  const validatorIdRegistryPort = {
+    getAllIds: () => validatorIdRegistryAdapter.getAllIds(),
+  };
+
+  // UseCases
+  const judgeUseCase = new JudgeQuickModeEligibilityUseCase({
+    changedFilesPort,
+    quickModeConfigPort,
+    judgmentEngine,
+  });
+
+  const buildUseCase = new BuildRelaxationProfileUseCase({
+    quickModeConfigPort,
+    validatorIdRegistryPort,
+    relaxationService,
+  });
+
+  const executeUseCase = new ExecuteQuickCiCheckUseCase({
+    judgeUseCase,
+    buildUseCase,
+  });
+
+  // Presentation
+  const handler = new CiCheckQuickModeHandler({ useCase: executeUseCase });
+
+  return {
+    handler,
+    executeUseCase,
+    judgeUseCase,
+    buildUseCase,
+  };
+}

package/scripts/harness/quick-mode/domain/ports/changed-files-port.ts

@@ -0,0 +1,12 @@
+/**
+ * @layer domain
+ * @unit quick-mode
+ *
+ * 変更ファイル一覧を取得するドメインポート
+ */
+
+import type { ChangedFile } from '../value-objects/changed-file.js';
+
+export interface ChangedFilesPort {
+  getChangedFiles(): Promise<readonly ChangedFile[]>;
+}

package/scripts/harness/quick-mode/domain/ports/quick-mode-config-port.ts

@@ -0,0 +1,12 @@
+/**
+ * @layer domain
+ * @unit quick-mode
+ *
+ * QuickModeConfig取得のドメインポート
+ */
+
+import type { QuickModeConfig } from '../value-objects/quick-mode-config.js';
+
+export interface QuickModeConfigPort {
+  getQuickModeConfig(): Promise<QuickModeConfig>;
+}

package/scripts/harness/quick-mode/domain/ports/validator-id-registry-port.ts

@@ -0,0 +1,10 @@
+/**
+ * @layer domain
+ * @unit quick-mode
+ *
+ * ValidatorId一覧取得のドメインポート
+ */
+
+export interface ValidatorIdRegistryPort {
+  getAllValidatorIds(): Promise<readonly string[]>;
+}

package/scripts/harness/quick-mode/domain/services/quick-mode-judgment-engine.ts

@@ -0,0 +1,148 @@
+/**
+ * @layer domain
+ * @unit quick-mode
+ *
+ * ChangedFile[]をChangeClassificationに変換し、3拒否ルールを評価してQuickModeEligibilityを返すドメインサービス
+ */
+
+import { ChangeCategory } from '../value-objects/change-category.js';
+import { ChangeClassification } from '../value-objects/change-classification.js';
+import { QuickModeEligibility } from '../value-objects/quick-mode-eligibility.js';
+import type { ChangedFile } from '../value-objects/changed-file.js';
+import type { QuickModeConfig } from '../value-objects/quick-mode-config.js';
+
+// リスク順優先度（api > domain > feature > bugfix > test > config > docs）
+const RISK_PRIORITY: Record<string, number> = {
+  api: 6,
+  domain: 5,
+  feature: 4,
+  bugfix: 3,
+  test: 2,
+  config: 1,
+  docs: 0,
+};
+
+function categorizeFile(file: ChangedFile): ChangeCategory {
+  const { filePath, changeKind } = file;
+
+  // api: *port.ts or *adapter.ts（最高優先度）
+  if (filePath.endsWith('port.ts') || filePath.endsWith('adapter.ts')) {
+    return ChangeCategory.fromString('api');
+  }
+
+  // test: __tests__/ 配下 or *.test.ts or *.spec.ts（domainより優先）
+  if (
+    filePath.includes('__tests__/') ||
+    filePath.endsWith('.test.ts') ||
+    filePath.endsWith('.spec.ts')
+  ) {
+    return ChangeCategory.fromString('test');
+  }
+
+  // domain: domain/ 配下
+  if (filePath.includes('/domain/') || filePath.startsWith('domain/')) {
+    return ChangeCategory.fromString('domain');
+  }
+
+  // docs: docs/ 配下
+  if (filePath.startsWith('docs/') || filePath.includes('/docs/')) {
+    return ChangeCategory.fromString('docs');
+  }
+
+  // config: *.config.json / *.config.ts / phasegate.config.json
+  if (
+    filePath.endsWith('.config.json') ||
+    filePath.endsWith('.config.ts') ||
+    filePath.endsWith('phasegate.config.json')
+  ) {
+    return ChangeCategory.fromString('config');
+  }
+
+  // feature: domain/ 以外の CREATE
+  if (changeKind === 'CREATE') {
+    return ChangeCategory.fromString('feature');
+  }
+
+  // bugfix: domain/ 以外の MODIFY/DELETE
+  return ChangeCategory.fromString('bugfix');
+}
+
+export class QuickModeJudgmentEngine {
+  classify(changedFiles: readonly ChangedFile[], _config?: QuickModeConfig): ChangeClassification {
+    if (changedFiles.length === 0) {
+      return new ChangeClassification(null, new Map(), 0);
+    }
+
+    const categorizedMap = new Map<string, ChangedFile[]>();
+    let dominantCategory: ChangeCategory | null = null;
+    let dominantPriority = -1;
+
+    for (const file of changedFiles) {
+      const category = categorizeFile(file);
+      const key = category.toString();
+
+      if (!categorizedMap.has(key)) {
+        categorizedMap.set(key, []);
+      }
+      categorizedMap.get(key)!.push(file);
+
+      const priority = RISK_PRIORITY[key] ?? 0;
+      if (priority > dominantPriority) {
+        dominantPriority = priority;
+        dominantCategory = category;
+      }
+    }
+
+    return new ChangeClassification(dominantCategory, categorizedMap, changedFiles.length);
+  }
+
+  judge(changedFiles: readonly ChangedFile[], config: QuickModeConfig): QuickModeEligibility {
+    const classification = this.classify(changedFiles, config);
+
+    // 1. MIXED_CHANGES評価: allowedCategories 外のカテゴリが含まれる場合
+    const notAllowedFiles: ChangedFile[] = [];
+    classification.categorizedFiles.forEach((files, categoryKey) => {
+      if (!config.isAllowed(categoryKey)) {
+        notAllowedFiles.push(...files);
+      }
+    });
+
+    if (notAllowedFiles.length > 0) {
+      return QuickModeEligibility.rejected(
+        'MIXED_CHANGES',
+        notAllowedFiles,
+        `allowedCategories外のファイルが含まれています: ${notAllowedFiles.map((f) => f.filePath).join(', ')}`
+      );
+    }
+
+    // 2. NEW_DOMAIN評価: domain/ 配下かつ changeKind=CREATE
+    const newDomainFiles = changedFiles.filter(
+      (f) =>
+        (f.filePath.includes('/domain/') || f.filePath.startsWith('domain/')) &&
+        f.changeKind === 'CREATE'
+    );
+
+    if (newDomainFiles.length > 0) {
+      return QuickModeEligibility.rejected(
+        'NEW_DOMAIN',
+        newDomainFiles,
+        `domain/配下に新規ファイルが追加されています: ${newDomainFiles.map((f) => f.filePath).join(', ')}`
+      );
+    }
+
+    // 3. API_CONTRACT評価: *port.ts / *adapter.ts の変更
+    const apiContractFiles = changedFiles.filter(
+      (f) => f.filePath.endsWith('port.ts') || f.filePath.endsWith('adapter.ts')
+    );
+
+    if (apiContractFiles.length > 0) {
+      return QuickModeEligibility.rejected(
+        'API_CONTRACT',
+        apiContractFiles,
+        `Port/Adapterインターフェースファイルの変更が含まれています: ${apiContractFiles.map((f) => f.filePath).join(', ')}`
+      );
+    }
+
+    return QuickModeEligibility.eligible('すべてのファイルが許可カテゴリ内です');
+  }
+}

package/scripts/harness/quick-mode/domain/services/validator-relaxation-service.ts

@@ -0,0 +1,47 @@
+/**
+ * @layer domain
+ * @unit quick-mode
+ *
+ * QuickModeConfigと全ValidatorId[]からValidatorRelaxationProfileを生成するドメインサービス
+ */
+
+import { ValidatorRelaxationProfile } from '../value-objects/validator-relaxation-profile.js';
+import type { QuickModeConfig } from '../value-objects/quick-mode-config.js';
+
+export class ValidatorRelaxationService {
+  build(
+    config: QuickModeConfig,
+    allValidatorIds: readonly string[]
+  ): ValidatorRelaxationProfile {
+    // L2 IDの分類
+    const l2Ids = allValidatorIds.filter((id) => id.startsWith('L2-'));
+    const l2Maintained: string[] = [];
+    const l2Skipped: string[] = [];
+
+    for (const id of l2Ids) {
+      if (config.isMaintained(id)) {
+        l2Maintained.push(id);
+      } else {
+        l2Skipped.push(id);
+      }
+    }
+
+    // L3 IDの分類
+    const l3Ids = allValidatorIds.filter((id) => id.startsWith('L3-'));
+    const l3Maintained: string[] = [];
+    const l3Skipped: string[] = [];
+
+    for (const id of l3Ids) {
+      if (config.isMaintained(id)) {
+        l3Maintained.push(id);
+      } else {
+        l3Skipped.push(id);
+      }
+    }
+
+    return ValidatorRelaxationProfile.create({
+      l2: { maintained: l2Maintained, skipped: l2Skipped },
+      l3: { maintained: l3Maintained, skipped: l3Skipped },
+    });
+  }
+}

package/scripts/harness/quick-mode/domain/types/change-kind.ts

@@ -0,0 +1,14 @@
+/**
+ * @layer domain
+ * @unit quick-mode
+ *
+ * 変更種別を表す列挙型
+ */
+
+export type ChangeKind = 'CREATE' | 'MODIFY' | 'DELETE';
+
+export const CHANGE_KINDS: readonly ChangeKind[] = ['CREATE', 'MODIFY', 'DELETE'] as const;
+
+export function isChangeKind(value: string): value is ChangeKind {
+  return CHANGE_KINDS.includes(value as ChangeKind);
+}

package/scripts/harness/quick-mode/domain/types/rejection-rule.ts

@@ -0,0 +1,8 @@
+/**
+ * @layer domain
+ * @unit quick-mode
+ *
+ * Quick Mode拒否ルール識別子
+ */
+
+export type RejectionRule = 'MIXED_CHANGES' | 'NEW_DOMAIN' | 'API_CONTRACT';

package/scripts/harness/quick-mode/domain/value-objects/change-category.ts

@@ -0,0 +1,60 @@
+/**
+ * @layer domain
+ * @unit quick-mode
+ *
+ * 変更カテゴリを表す値オブジェクト
+ */
+
+export type ChangeCategoryValue =
+  | 'bugfix'
+  | 'docs'
+  | 'test'
+  | 'config'
+  | 'feature'
+  | 'domain'
+  | 'api';
+
+const VALID_CATEGORIES: readonly ChangeCategoryValue[] = [
+  'bugfix',
+  'docs',
+  'test',
+  'config',
+  'feature',
+  'domain',
+  'api',
+] as const;
+
+export class UnknownChangeCategoryError extends Error {
+  constructor(raw: string) {
+    super(`Unknown change category: "${raw}". Valid values: ${VALID_CATEGORIES.join(', ')}`);
+    this.name = 'UnknownChangeCategoryError';
+  }
+}
+
+export class ChangeCategory {
+  private readonly value: ChangeCategoryValue;
+
+  private constructor(value: ChangeCategoryValue) {
+    this.value = value;
+  }
+
+  static fromString(raw: string): ChangeCategory {
+    const normalized = raw.toLowerCase();
+    if (!VALID_CATEGORIES.includes(normalized as ChangeCategoryValue)) {
+      throw new UnknownChangeCategoryError(raw);
+    }
+    return new ChangeCategory(normalized as ChangeCategoryValue);
+  }
+
+  isQuickModeRejectable(): boolean {
+    return this.value === 'domain' || this.value === 'feature' || this.value === 'api';
+  }
+
+  toString(): string {
+    return this.value;
+  }
+
+  equals(other: ChangeCategory): boolean {
+    return this.value === other.value;
+  }
+}

package/scripts/harness/quick-mode/domain/value-objects/change-classification.ts

@@ -0,0 +1,68 @@
+/**
+ * @layer domain
+ * @unit quick-mode
+ *
+ * ChangedFile[]の分類結果を表す値オブジェクト
+ */
+
+import type { ChangeCategory } from './change-category.js';
+import type { ChangedFile } from './changed-file.js';
+
+export class ChangeClassification {
+  readonly dominantCategory: ChangeCategory | null;
+  readonly categorizedFiles: ReadonlyMap<string, readonly ChangedFile[]>;
+  readonly totalFiles: number;
+
+  constructor(
+    dominantCategory: ChangeCategory | null,
+    categorizedFiles: ReadonlyMap<string, readonly ChangedFile[]>,
+    totalFiles: number
+  ) {
+    this.dominantCategory = dominantCategory;
+    this.categorizedFiles = categorizedFiles;
+    this.totalFiles = totalFiles;
+  }
+
+  getFiles(category: ChangeCategory | string): readonly ChangedFile[] {
+    const key = typeof category === 'string' ? category : category.toString();
+    return this.categorizedFiles.get(key) ?? [];
+  }
+
+  hasCategory(category: ChangeCategory | string): boolean {
+    const key = typeof category === 'string' ? category : category.toString();
+    const files = this.categorizedFiles.get(key);
+    return files !== undefined && files.length > 0;
+  }
+
+  hasAnyRejectable(): boolean {
+    return (
+      this.hasCategory('domain') ||
+      this.hasCategory('feature') ||
+      this.hasCategory('api')
+    );
+  }
+
+  equals(other: ChangeClassification): boolean {
+    if (this.totalFiles !== other.totalFiles) return false;
+    if (this.dominantCategory?.toString() !== other.dominantCategory?.toString()) return false;
+
+    let equal = true;
+    this.categorizedFiles.forEach((files, key) => {
+      if (!equal) return;
+      const otherFiles = other.categorizedFiles.get(key);
+      if (!otherFiles || files.length !== otherFiles.length) {
+        equal = false;
+        return;
+      }
+      for (let i = 0; i < files.length; i++) {
+        if (!files[i].equals(otherFiles[i])) {
+          equal = false;
+          return;
+        }
+      }
+    });
+    if (!equal) return false;
+
+    return true;
+  }
+}