phasegate 0.44.0 → 0.63.0

package/scripts/harness/phase2-extensions/infrastructure/adapters/git-log-initial-creation-age-adapter.ts

@@ -0,0 +1,77 @@
+/**
+ * @layer infrastructure
+ * @unit phase2-extensions
+ */
+import { execSync } from 'node:child_process';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import type { InitialCreationAgePort } from '../../domain/ports/initial-creation-age-port.js';
+import { InitialCreationAge } from '../../domain/value-objects/initial-creation-age.js';
+
+type GitExecutor = (
+  command: string,
+  options: { cwd: string; stdio?: readonly ['pipe', 'pipe', 'pipe'] },
+) => Buffer;
+
+function diffInDays(now: Date, past: Date): number {
+  const millisecondsPerDay = 1000 * 60 * 60 * 24;
+  return Math.max(0, Math.floor((now.getTime() - past.getTime()) / millisecondsPerDay));
+}
+
+export class GitLogInitialCreationAgeAdapter implements InitialCreationAgePort {
+  constructor(
+    private readonly projectRoot: string,
+    private readonly nowProvider: () => Date = () => new Date(),
+    private readonly gitExecutor: GitExecutor = execSync,
+  ) {}
+
+  async getAge(filePath: string): Promise<InitialCreationAge> {
+    const dateOutput = this.runGit(`git log --diff-filter=A --format=%ai -- "${filePath}"`);
+    const countOutput = this.runGit(`git rev-list --count HEAD -- "${filePath}"`);
+
+    if (dateOutput !== null && dateOutput.length > 0) {
+      const commitCount = this.parseCount(countOutput);
+
+      return InitialCreationAge.create({
+        ageInDays: diffInDays(this.nowProvider(), new Date(dateOutput.split('\n')[0].trim())),
+        commitCount: commitCount > 0 ? commitCount : 1,
+        source: 'git-log',
+      });
+    }
+
+    return this.fileMtimeFallback(filePath);
+  }
+
+  private runGit(command: string): string | null {
+    try {
+      return this.gitExecutor(command, {
+        cwd: this.projectRoot,
+        // ISSUE-005 P1-3 と同様に、fresh repo の fatal stderr を静音化する。
+        stdio: ['pipe', 'pipe', 'pipe'] as const,
+      })
+        .toString()
+        .trim();
+    } catch {
+      return null;
+    }
+  }
+
+  private parseCount(output: string | null): number {
+    if (output === null || output.length === 0) {
+      return 1;
+    }
+
+    const parsed = Number.parseInt(output.trim(), 10);
+    return Number.isFinite(parsed) && parsed >= 1 ? parsed : 1;
+  }
+
+  private async fileMtimeFallback(filePath: string): Promise<InitialCreationAge> {
+    const stat = await fs.stat(path.resolve(this.projectRoot, filePath));
+
+    return InitialCreationAge.create({
+      ageInDays: diffInDays(this.nowProvider(), stat.mtime),
+      commitCount: 1,
+      source: 'file-mtime',
+    });
+  }
+}

package/scripts/harness/phase2-extensions/infrastructure/adapters/harness-config-initial-creation-expiration-adapter.ts

@@ -0,0 +1,57 @@
+/**
+ * @layer infrastructure
+ * @unit phase2-extensions
+ */
+import type { HarnessConfigV2 } from '../../../config-foundation/domain/harness-config.js';
+import { InitialCreationExpirationRule } from '../../domain/aggregates/initial-creation-expiration-rule.js';
+import type { InitialCreationExpirationConfigPort } from '../../domain/ports/initial-creation-expiration-config-port.js';
+
+type Phase2InitialCreationConfig = {
+  phase2Extensions?: {
+    initialCreationExpirationRules?: Array<{
+      ruleId: string;
+      documentPattern: string;
+      daysThreshold: number;
+      commitCountThreshold: number;
+      evaluationMode: 'or' | 'and';
+      enabled?: boolean;
+    }>;
+  };
+};
+
+const DEFAULT_RULE_CONFIG = {
+  ruleId: 'default-initial-creation-expiration',
+  documentPattern: 'docs/**/*.md',
+  daysThreshold: 90,
+  commitCountThreshold: 5,
+  evaluationMode: 'or' as const,
+  enabled: true,
+};
+
+export class HarnessConfigInitialCreationExpirationAdapter
+  implements InitialCreationExpirationConfigPort
+{
+  constructor(private readonly config?: HarnessConfigV2 | Phase2InitialCreationConfig) {}
+
+  async loadRules(): Promise<InitialCreationExpirationRule[]> {
+    const configRules =
+      this.config && 'phase2Extensions' in this.config
+        ? this.config.phase2Extensions?.initialCreationExpirationRules
+        : undefined;
+
+    if (!configRules || configRules.length === 0) {
+      return [InitialCreationExpirationRule.create(DEFAULT_RULE_CONFIG)];
+    }
+
+    return configRules.map((rule) =>
+      InitialCreationExpirationRule.create({
+        ruleId: rule.ruleId,
+        documentPattern: rule.documentPattern,
+        daysThreshold: rule.daysThreshold,
+        commitCountThreshold: rule.commitCountThreshold,
+        evaluationMode: rule.evaluationMode,
+        enabled: rule.enabled ?? true,
+      }),
+    );
+  }
+}

package/scripts/harness/phase2-extensions/infrastructure/adapters/markdown-frontmatter-reader-adapter.ts

@@ -0,0 +1,56 @@
+/**
+ * @layer infrastructure
+ * @unit phase2-extensions
+ */
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { parseFrontmatterFlags } from '../../../traceability-model/infrastructure/parsers/frontmatter-flag-parser.js';
+import type {
+  FrontmatterReadResult,
+  FrontmatterReaderPort,
+} from '../../domain/ports/frontmatter-reader-port.js';
+
+const FRONTMATTER_INITIAL_CREATION_PATTERN =
+  /^---\r?\n[\s\S]*?^\s*initial_creation\s*:\s*(.+)\s*$/m;
+
+export class MarkdownFrontmatterReaderAdapter implements FrontmatterReaderPort {
+  constructor(private readonly projectRoot: string) {}
+
+  async read(filePath: string): Promise<FrontmatterReadResult> {
+    try {
+      const absolutePath = path.resolve(this.projectRoot, filePath);
+      const content = await fs.readFile(absolutePath, 'utf8');
+
+      try {
+        const initialCreationMatch = FRONTMATTER_INITIAL_CREATION_PATTERN.exec(content);
+        if (initialCreationMatch) {
+          const rawValue = initialCreationMatch[1].trim();
+          if (rawValue !== 'true' && rawValue !== 'false') {
+            throw new Error(
+              `traceability.initial_creation の値が不正です（true/false のみ許容）: ${rawValue}`,
+            );
+          }
+        }
+
+        const parsed = parseFrontmatterFlags(content);
+        return {
+          filePath,
+          flags: { initialCreation: parsed.initialCreation },
+          parseError: null,
+        };
+      } catch (error) {
+        return {
+          filePath,
+          flags: null,
+          parseError: error instanceof Error ? error.message : 'unknown parse error',
+        };
+      }
+    } catch (error) {
+      return {
+        filePath,
+        flags: null,
+        parseError: error instanceof Error ? `read failed: ${error.message}` : 'read failed',
+      };
+    }
+  }
+}

package/scripts/harness/phase2-extensions/presentation/formatters/initial-creation-expiration-result-formatter.ts

@@ -0,0 +1,23 @@
+/**
+ * @layer presentation
+ * @unit phase2-extensions
+ */
+import type { CheckInitialCreationExpirationOutput } from '../../application/dto/check-initial-creation-expiration-output.js';
+
+export class InitialCreationExpirationResultFormatter {
+  formatJson(result: CheckInitialCreationExpirationOutput): string {
+    return JSON.stringify(result, null, 2);
+  }
+
+  formatText(result: CheckInitialCreationExpirationOutput): string {
+    const header = `total=${result.summary.total} ok=${result.summary.ok} warn=${result.summary.warn}`;
+    const entries = result.results.map(
+      (entry) =>
+        `${entry.level}: ${entry.documentPath} (ageInDays=${entry.ageInDays}, commitCount=${entry.commitCount}, source=${entry.ageSource})`,
+    );
+    const warnings = result.warnings.map((warning) => `warning ${warning.code}: ${warning.message}`);
+    const errors = result.errors.map((error) => `error ${error.code}: ${error.message}`);
+
+    return [header, ...entries, ...warnings, ...errors].join('\n');
+  }
+}

package/scripts/harness/phase2-extensions/presentation/handlers/check-initial-creation-expiration-handler.ts

@@ -0,0 +1,38 @@
+/**
+ * @layer presentation
+ * @unit phase2-extensions
+ */
+import type { CheckInitialCreationExpirationUseCase } from '../../application/usecases/check-initial-creation-expiration-usecase.js';
+import { InitialCreationExpirationResultFormatter } from '../formatters/initial-creation-expiration-result-formatter.js';
+
+export class CheckInitialCreationExpirationHandler {
+  private readonly formatter = new InitialCreationExpirationResultFormatter();
+
+  constructor(private readonly useCase: CheckInitialCreationExpirationUseCase) {}
+
+  async handle(args: string[]): Promise<{ exitCode: number; stdout: string }> {
+    let targetPattern: string | undefined;
+    let format: 'text' | 'json' = 'text';
+    let dryRun = false;
+
+    for (let index = 0; index < args.length; index += 1) {
+      const arg = args[index];
+      if (arg === '--pattern') {
+        targetPattern = args[index + 1];
+        index += 1;
+      } else if (arg === '--format') {
+        format = (args[index + 1] as 'text' | 'json') ?? 'text';
+        index += 1;
+      } else if (arg === '--dry-run') {
+        dryRun = true;
+      }
+    }
+
+    const result = await this.useCase.execute({ targetPattern, format, dryRun });
+
+    return {
+      exitCode: result.errors.length > 0 ? 1 : 0,
+      stdout: format === 'json' ? this.formatter.formatJson(result) : this.formatter.formatText(result),
+    };
+  }
+}

package/scripts/harness/quick-mode/application/dto/change-category-classification-contract.ts

@@ -0,0 +1,20 @@
+/**
+ * @layer application
+ * @unit quick-mode
+ * @story H10-05
+ *
+ * ChangeCategoryClassification の公開 DTO
+ */
+
+export interface ChangeCategoryPerFile {
+  readonly path: string;
+  readonly category: string;
+}
+
+export interface ChangeCategoryClassificationContract {
+  readonly dominantCategory: string | null;
+  readonly perFile: readonly ChangeCategoryPerFile[];
+  readonly fullModeRequired: boolean;
+  readonly rejectionRule?: 'MIXED_CHANGES' | 'NEW_DOMAIN' | 'API_CONTRACT';
+  readonly rejectionReason?: string;
+}

package/scripts/harness/quick-mode/application/usecases/classify-change-category-usecase.ts

@@ -0,0 +1,83 @@
+/**
+ * @layer application
+ * @unit quick-mode
+ * @story H10-05
+ *
+ * paths から変更カテゴリを分類し fullModeRequired 判定と理由を返す UseCase
+ */
+
+import { ChangedFile } from '../../domain/value-objects/changed-file.js';
+import { QuickModeJudgmentEngine } from '../../domain/services/quick-mode-judgment-engine.js';
+import type { QuickModeConfigPort } from '../ports/quick-mode-config-port.js';
+import type { ChangeCategoryClassificationContract, ChangeCategoryPerFile } from '../dto/change-category-classification-contract.js';
+
+export interface ClassifyChangeCategoryUseCaseInput {
+  readonly paths: readonly string[];
+}
+
+export interface ClassifyChangeCategoryUseCaseDeps {
+  quickModeConfigPort: QuickModeConfigPort;
+  judgmentEngine?: QuickModeJudgmentEngine;
+}
+
+export class ClassifyChangeCategoryUseCase {
+  private readonly quickModeConfigPort: QuickModeConfigPort;
+  private readonly judgmentEngine: QuickModeJudgmentEngine;
+
+  constructor(deps: ClassifyChangeCategoryUseCaseDeps) {
+    this.quickModeConfigPort = deps.quickModeConfigPort;
+    this.judgmentEngine = deps.judgmentEngine ?? new QuickModeJudgmentEngine();
+  }
+
+  async execute(
+    input: ClassifyChangeCategoryUseCaseInput
+  ): Promise<Readonly<ChangeCategoryClassificationContract>> {
+    const config = await this.quickModeConfigPort.getConfig();
+
+    if (input.paths.length === 0) {
+      return Object.freeze({
+        dominantCategory: null,
+        perFile: [],
+        fullModeRequired: false,
+      });
+    }
+
+    const changedFiles = input.paths.map((p) =>
+      ChangedFile.create({ filePath: p, changeKind: 'MODIFY' })
+    );
+
+    const classification = this.judgmentEngine.classify(changedFiles, config);
+    const eligibility = this.judgmentEngine.judge(changedFiles, config);
+
+    const perFile: ChangeCategoryPerFile[] = [];
+    for (const path of input.paths) {
+      const match = changedFiles.find((f) => f.filePath === path);
+      if (!match) continue;
+      let categoryForFile: string | null = null;
+      classification.categorizedFiles.forEach((files, categoryKey) => {
+        if (files.some((f) => f.filePath === path)) {
+          categoryForFile = categoryKey;
+        }
+      });
+      perFile.push({ path, category: categoryForFile ?? 'unknown' });
+    }
+
+    const fullModeRequired = !eligibility.isEligible();
+
+    const contract: ChangeCategoryClassificationContract = fullModeRequired
+      ? {
+          dominantCategory: classification.dominantCategory?.toString() ?? null,
+          perFile,
+          fullModeRequired: true,
+          rejectionRule: eligibility.rejectionRule,
+          rejectionReason: eligibility.reason,
+        }
+      : {
+          dominantCategory: classification.dominantCategory?.toString() ?? null,
+          perFile,
+          fullModeRequired: false,
+        };
+
+    return Object.freeze(contract);
+  }
+}

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

@@ -14,13 +14,17 @@ import { QuickModeDecisionContractMapper } from './application/mappers/quick-mod
 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 { ClassifyChangeCategoryUseCase } from './application/usecases/classify-change-category-usecase.js';
 import { CiCheckQuickModeHandler } from './presentation/handlers/ci-check-quick-mode-handler.js';
+import { CheckChangeCategoryHandler } from './presentation/handlers/check-change-category-handler.js';
 
 export interface QuickModeCompositionRoot {
   handler: CiCheckQuickModeHandler;
+  checkChangeCategoryHandler: CheckChangeCategoryHandler;
   executeUseCase: ExecuteQuickCiCheckUseCase;
   judgeUseCase: JudgeQuickModeEligibilityUseCase;
   buildUseCase: BuildRelaxationProfileUseCase;
+  classifyUseCase: ClassifyChangeCategoryUseCase;
 }
 
 export function createQuickModeCompositionRoot(): QuickModeCompositionRoot {
@@ -62,13 +66,21 @@ export function createQuickModeCompositionRoot(): QuickModeCompositionRoot {
     buildUseCase,
   });
 
+  const classifyUseCase = new ClassifyChangeCategoryUseCase({
+    quickModeConfigPort,
+    judgmentEngine,
+  });
+
   // Presentation
   const handler = new CiCheckQuickModeHandler({ useCase: executeUseCase });
+  const checkChangeCategoryHandler = new CheckChangeCategoryHandler({ useCase: classifyUseCase });
 
   return {
     handler,
+    checkChangeCategoryHandler,
     executeUseCase,
     judgeUseCase,
     buildUseCase,
+    classifyUseCase,
   };
 }

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

@@ -100,47 +100,53 @@ export class QuickModeJudgmentEngine {
     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 (config.isFullModeRequiredFor('mixedCategories')) {
+      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(', ')}`
+        );
       }
-    });
-
-    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(', ')}`
+    if (config.isFullModeRequiredFor('newDomainFile')) {
+      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(', ')}`
+    if (config.isFullModeRequiredFor('apiContractChange')) {
+      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/value-objects/quick-mode-config.ts

@@ -12,20 +12,37 @@ export class QuickModeConfigError extends Error {
   }
 }
 
+export type FullModeRequiredRuleId = 'mixedCategories' | 'newDomainFile' | 'apiContractChange';
+
+export interface FullModeRequiredRules {
+  readonly mixedCategories: boolean;
+  readonly newDomainFile: boolean;
+  readonly apiContractChange: boolean;
+}
+
+const DEFAULT_FULL_MODE_REQUIRED_WHEN: FullModeRequiredRules = Object.freeze({
+  mixedCategories: true,
+  newDomainFile: true,
+  apiContractChange: true,
+});
+
 
 export class QuickModeConfig {
   readonly allowedCategories: readonly string[];
   readonly maintainedLayers: readonly string[];
   readonly relaxedGates: readonly string[];
+  readonly fullModeRequiredWhen: FullModeRequiredRules;
 
   private constructor(
     allowedCategories: readonly string[],
     maintainedLayers: readonly string[],
-    relaxedGates: readonly string[]
+    relaxedGates: readonly string[],
+    fullModeRequiredWhen: FullModeRequiredRules
   ) {
     this.allowedCategories = allowedCategories;
     this.maintainedLayers = maintainedLayers;
     this.relaxedGates = relaxedGates;
+    this.fullModeRequiredWhen = fullModeRequiredWhen;
     Object.freeze(this);
   }
 
@@ -33,17 +50,25 @@ export class QuickModeConfig {
     allowedCategories: string[];
     maintainedLayers: string[];
     relaxedGates: string[];
+    fullModeRequiredWhen?: Partial<FullModeRequiredRules>;
   }): QuickModeConfig {
-    const { allowedCategories, maintainedLayers, relaxedGates } = raw;
+    const { allowedCategories, maintainedLayers, relaxedGates, fullModeRequiredWhen } = raw;
 
     if (allowedCategories.length === 0) {
       throw new QuickModeConfigError('allowedCategories must not be empty');
     }
 
+    const mergedRules: FullModeRequiredRules = Object.freeze({
+      mixedCategories: fullModeRequiredWhen?.mixedCategories ?? DEFAULT_FULL_MODE_REQUIRED_WHEN.mixedCategories,
+      newDomainFile: fullModeRequiredWhen?.newDomainFile ?? DEFAULT_FULL_MODE_REQUIRED_WHEN.newDomainFile,
+      apiContractChange: fullModeRequiredWhen?.apiContractChange ?? DEFAULT_FULL_MODE_REQUIRED_WHEN.apiContractChange,
+    });
+
     return new QuickModeConfig(
       Object.freeze([...allowedCategories]),
       Object.freeze([...maintainedLayers]),
-      Object.freeze([...relaxedGates])
+      Object.freeze([...relaxedGates]),
+      mergedRules
     );
   }
 
@@ -59,11 +84,18 @@ export class QuickModeConfig {
     return this.relaxedGates.includes(validatorId);
   }
 
+  isFullModeRequiredFor(rule: FullModeRequiredRuleId): boolean {
+    return this.fullModeRequiredWhen[rule];
+  }
+
   equals(other: QuickModeConfig): boolean {
     return (
       JSON.stringify(this.allowedCategories) === JSON.stringify(other.allowedCategories) &&
       JSON.stringify(this.maintainedLayers) === JSON.stringify(other.maintainedLayers) &&
-      JSON.stringify(this.relaxedGates) === JSON.stringify(other.relaxedGates)
+      JSON.stringify(this.relaxedGates) === JSON.stringify(other.relaxedGates) &&
+      this.fullModeRequiredWhen.mixedCategories === other.fullModeRequiredWhen.mixedCategories &&
+      this.fullModeRequiredWhen.newDomainFile === other.fullModeRequiredWhen.newDomainFile &&
+      this.fullModeRequiredWhen.apiContractChange === other.fullModeRequiredWhen.apiContractChange
     );
   }
 }

package/scripts/harness/quick-mode/infrastructure/adapters/harness-config-quick-mode-config-adapter.ts

@@ -60,6 +60,11 @@ export class HarnessConfigQuickModeConfigAdapter {
       allowedCategories?: string[];
       maintainedLayers?: string[];
       relaxedGates?: string[];
+      fullModeRequiredWhen?: {
+        mixedCategories?: boolean;
+        newDomainFile?: boolean;
+        apiContractChange?: boolean;
+      };
     } | undefined;
 
     if (!quickMode) {
@@ -70,6 +75,7 @@ export class HarnessConfigQuickModeConfigAdapter {
       allowedCategories: quickMode.allowedCategories ?? DEFAULT_QUICK_MODE_CONFIG.allowedCategories,
       maintainedLayers: quickMode.maintainedLayers ?? DEFAULT_QUICK_MODE_CONFIG.maintainedLayers,
       relaxedGates: quickMode.relaxedGates ?? DEFAULT_QUICK_MODE_CONFIG.relaxedGates,
+      fullModeRequiredWhen: quickMode.fullModeRequiredWhen,
     });
   }
 }

package/scripts/harness/quick-mode/presentation/formatters/change-category-formatter.ts

@@ -0,0 +1,42 @@
+/**
+ * @layer presentation
+ * @unit quick-mode
+ * @story H10-05
+ *
+ * ClassifyChangeCategoryUseCase の出力を human / json フォーマットで整形する
+ */
+
+import type { ChangeCategoryClassificationContract } from '../../application/dto/change-category-classification-contract.js';
+
+export type ChangeCategoryOutputFormat = 'human' | 'json';
+
+export class ChangeCategoryFormatter {
+  format(
+    contract: ChangeCategoryClassificationContract,
+    format: ChangeCategoryOutputFormat = 'human'
+  ): string {
+    if (format === 'json') {
+      return JSON.stringify(contract, null, 2) + '\n';
+    }
+
+    const lines: string[] = [];
+    lines.push(`dominantCategory: ${contract.dominantCategory ?? '(none)'}`);
+    lines.push(`fullModeRequired: ${contract.fullModeRequired}`);
+
+    if (contract.fullModeRequired) {
+      lines.push(`rejectionRule: ${contract.rejectionRule ?? ''}`);
+      if (contract.rejectionReason) {
+        lines.push(`rejectionReason: ${contract.rejectionReason}`);
+      }
+    }
+
+    if (contract.perFile.length > 0) {
+      lines.push('perFile:');
+      for (const entry of contract.perFile) {
+        lines.push(`  ${entry.path} -> ${entry.category}`);
+      }
+    }
+
+    return lines.join('\n') + '\n';
+  }
+}