phasegate 0.62.0 → 0.63.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "phasegate",
-  "version": "0.62.0",
+  "version": "0.63.0",
   "packageManager": "pnpm@10.30.1",
   "description": "Phasegate — AI-agnostic quality defense toolkit. Enforces structural integrity between design intent and code.",
   "license": "Apache-2.0",

package/scripts/harness/config-foundation/infrastructure/schemas/harness-config-v2.schema.json

@@ -153,6 +153,21 @@
             "type": "string"
           },
           "uniqueItems": true
+        },
+        "fullModeRequiredWhen": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "mixedCategories": {
+              "type": "boolean"
+            },
+            "newDomainFile": {
+              "type": "boolean"
+            },
+            "apiContractChange": {
+              "type": "boolean"
+            }
+          }
         }
       }
     },

package/scripts/harness/main.ts

@@ -716,6 +716,41 @@ async function main(): Promise<void> {
         break;
       }
 
+      // ── quick-mode / check-change-category (H10-05) ──
+      case 'check-change-category': {
+        if (hasFlag(args, '--help')) {
+          process.stdout.write([
+            'Usage: phasegate check-change-category --paths <csv> [options]',
+            '',
+            'Classify changed file paths into quick-mode categories and report',
+            'whether Full Mode is required.',
+            '',
+            'Options:',
+            '  --paths <csv>              Comma-separated file paths to classify.',
+            '  --format <human|json>      Output format. Default: human.',
+            '  --fail-on-full-required    Exit with code 1 when Full Mode is required.',
+            '  --help                     Show this help.',
+            '',
+            'Examples:',
+            '  phasegate check-change-category --paths src/foo.ts,src/bar.ts',
+            '  phasegate check-change-category --paths src/foo.ts --format json',
+            '',
+          ].join('\n'));
+          return;
+        }
+        const mod = createQuickModeCompositionRoot();
+        const paths = parseFlag(args, '--paths');
+        const format = parseFlag(args, '--format') as 'human' | 'json' | undefined;
+        const failOnFullRequired = hasFlag(args, '--fail-on-full-required');
+        const result = await mod.checkChangeCategoryHandler.handle({
+          paths,
+          format,
+          failOnFullRequired,
+        });
+        process.exit(result.exitCode);
+        break;
+      }
+
       // ── harness-api ──
       case 'phasegate:check-ready': {
         const mod = createHarnessApiModule();

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';
+  }
+}

package/scripts/harness/quick-mode/presentation/handlers/check-change-category-handler.ts

@@ -0,0 +1,50 @@
+/**
+ * @layer presentation
+ * @unit quick-mode
+ * @story H10-05
+ *
+ * phasegate check-change-category CLI のハンドラ
+ */
+
+import type { ClassifyChangeCategoryUseCase } from '../../application/usecases/classify-change-category-usecase.js';
+import { ChangeCategoryFormatter, type ChangeCategoryOutputFormat } from '../formatters/change-category-formatter.js';
+
+export interface CheckChangeCategoryHandlerDeps {
+  useCase: Pick<ClassifyChangeCategoryUseCase, 'execute'>;
+  writer?: (s: string) => void;
+}
+
+export interface CheckChangeCategoryHandlerOptions {
+  paths?: string;
+  format?: ChangeCategoryOutputFormat;
+  failOnFullRequired?: boolean;
+}
+
+export interface CheckChangeCategoryHandlerResult {
+  exitCode: number;
+}
+
+export class CheckChangeCategoryHandler {
+  private readonly useCase: Pick<ClassifyChangeCategoryUseCase, 'execute'>;
+  private readonly writer: (s: string) => void;
+  private readonly formatter = new ChangeCategoryFormatter();
+
+  constructor(deps: CheckChangeCategoryHandlerDeps) {
+    this.useCase = deps.useCase;
+    this.writer = deps.writer ?? ((s: string) => process.stdout.write(s));
+  }
+
+  async handle(options: CheckChangeCategoryHandlerOptions): Promise<CheckChangeCategoryHandlerResult> {
+    const { paths: pathsRaw, format = 'human', failOnFullRequired = false } = options;
+
+    const paths = pathsRaw
+      ? pathsRaw.split(',').map((p) => p.trim()).filter((p) => p.length > 0)
+      : [];
+
+    const contract = await this.useCase.execute({ paths });
+    this.writer(this.formatter.format(contract, format));
+
+    const exitCode = failOnFullRequired && contract.fullModeRequired ? 1 : 0;
+    return { exitCode };
+  }
+}