phasegate 0.15.0

package/scripts/harness/phase2-extensions/infrastructure/adapters/harness-config-freshness-adapter.ts

@@ -0,0 +1,77 @@
+/**
+ * @layer infrastructure
+ * @unit phase2-extensions
+ */
+import type { HarnessConfigV2 } from '../../../config-foundation/domain/harness-config.js';
+import { DocFreshnessRule } from '../../domain/aggregates/doc-freshness-rule.js';
+import { PointerRule } from '../../domain/aggregates/pointer-rule.js';
+import type { FreshnessConfigPort } from '../../domain/ports/freshness-config-port.js';
+import { FreshnessThreshold } from '../../domain/value-objects/freshness-threshold.js';
+
+type Phase2RuleConfig = {
+  phase2Extensions?: {
+    freshnessRules?: Array<{
+      ruleId: string;
+      documentPattern: string;
+      warnThresholdDays: number;
+      errorThresholdDays: number;
+      enabled?: boolean;
+    }>;
+    pointerRules?: Array<{
+      ruleId: string;
+      documentPattern: string;
+      failOnBroken?: boolean;
+    }>;
+  };
+};
+
+export class HarnessConfigFreshnessAdapter implements FreshnessConfigPort {
+  constructor(private readonly config?: HarnessConfigV2 | Phase2RuleConfig) {}
+
+  async loadRules(): Promise<DocFreshnessRule[]> {
+    const configRules = this.config && 'phase2Extensions' in this.config ? this.config.phase2Extensions?.freshnessRules : undefined;
+    if (!configRules || configRules.length === 0) {
+      return [
+        DocFreshnessRule.create({
+          ruleId: 'default-doc-freshness',
+          documentPattern: 'docs/**/*.md',
+          threshold: FreshnessThreshold.create({ warnThresholdDays: 30, errorThresholdDays: 90 }),
+          enabled: true,
+        }),
+      ];
+    }
+
+    return configRules.map((rule) =>
+      DocFreshnessRule.create({
+        ruleId: rule.ruleId,
+        documentPattern: rule.documentPattern,
+        threshold: FreshnessThreshold.create({
+          warnThresholdDays: rule.warnThresholdDays,
+          errorThresholdDays: rule.errorThresholdDays,
+        }),
+        enabled: rule.enabled ?? true,
+      }),
+    );
+  }
+
+  async loadPointerRules(): Promise<PointerRule[]> {
+    const configRules = this.config && 'phase2Extensions' in this.config ? this.config.phase2Extensions?.pointerRules : undefined;
+    if (!configRules || configRules.length === 0) {
+      return [
+        PointerRule.create({
+          ruleId: 'default-pointer-rule',
+          documentPattern: 'docs/**/*.md',
+          failOnBroken: true,
+        }),
+      ];
+    }
+
+    return configRules.map((rule) =>
+      PointerRule.create({
+        ruleId: rule.ruleId,
+        documentPattern: rule.documentPattern,
+        failOnBroken: rule.failOnBroken ?? true,
+      }),
+    );
+  }
+}

package/scripts/harness/phase2-extensions/infrastructure/adapters/playwright-template-generator-adapter.ts

@@ -0,0 +1,154 @@
+/**
+ * @layer infrastructure
+ * @unit phase2-extensions
+ */
+
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+
+export interface PlaywrightTemplateConfig {
+  projectName: string;
+  baseUrl: string;
+}
+
+export interface PlaywrightTemplateResult {
+  generatedFiles: string[];
+  errors: string[];
+}
+
+export class PlaywrightTemplateGeneratorAdapter {
+  constructor(private readonly config: PlaywrightTemplateConfig) {}
+
+  async generate(outputDir: string): Promise<PlaywrightTemplateResult> {
+    const generatedFiles: string[] = [];
+    const errors: string[] = [];
+
+    const files: { relativePath: string; content: string }[] = [
+      { relativePath: 'playwright.config.ts', content: this.generateConfig() },
+      { relativePath: path.join('pages', 'base-page.ts'), content: this.generateBasePage() },
+      { relativePath: path.join('fixtures', 'seed-data.ts'), content: this.generateSeedData() },
+      { relativePath: path.join('tests', 'example.spec.ts'), content: this.generateExampleSpec() },
+    ];
+
+    for (const file of files) {
+      const fullPath = path.join(outputDir, file.relativePath);
+      try {
+        await fs.mkdir(path.dirname(fullPath), { recursive: true });
+        await fs.writeFile(fullPath, file.content, 'utf8');
+        generatedFiles.push(file.relativePath);
+      } catch (err) {
+        errors.push(`Failed to write ${file.relativePath}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+
+    return { generatedFiles, errors };
+  }
+
+  private generateConfig(): string {
+    return `import { defineConfig, devices } from '@playwright/test';
+
+export default defineConfig({
+  testDir: './tests',
+  fullyParallel: true,
+  forbidOnly: !!process.env.CI,
+  retries: process.env.CI ? 2 : 0,
+  workers: process.env.CI ? 1 : undefined,
+  reporter: 'html',
+  use: {
+    baseURL: '${this.config.baseUrl}',
+    trace: 'on-first-retry',
+  },
+  projects: [
+    {
+      name: 'chromium',
+      use: { ...devices['Desktop Chrome'] },
+    },
+    {
+      name: 'firefox',
+      use: { ...devices['Desktop Firefox'] },
+    },
+    {
+      name: 'webkit',
+      use: { ...devices['Desktop Safari'] },
+    },
+  ],
+});
+`;
+  }
+
+  private generateBasePage(): string {
+    return `import { type Page, type Locator } from '@playwright/test';
+
+export abstract class BasePage {
+  constructor(protected readonly page: Page) {}
+
+  async navigate(path: string): Promise<void> {
+    await this.page.goto(path);
+  }
+
+  async waitForPageLoad(): Promise<void> {
+    await this.page.waitForLoadState('networkidle');
+  }
+
+  protected getByTestId(testId: string): Locator {
+    return this.page.getByTestId(testId);
+  }
+
+  protected getByRole(role: Parameters<Page['getByRole']>[0], options?: Parameters<Page['getByRole']>[1]): Locator {
+    return this.page.getByRole(role, options);
+  }
+}
+`;
+  }
+
+  private generateSeedData(): string {
+    return `/**
+ * SeedData — E2Eテスト用シードデータ管理
+ * プロジェクト: ${this.config.projectName}
+ */
+
+export interface SeedData {
+  readonly id: string;
+  readonly name: string;
+  readonly data: Record<string, unknown>;
+}
+
+export const defaultSeeds: readonly SeedData[] = [
+  {
+    id: 'seed-001',
+    name: 'デフォルトユーザー',
+    data: {
+      email: 'test@example.com',
+      role: 'admin',
+    },
+  },
+];
+
+export async function loadSeeds(): Promise<readonly SeedData[]> {
+  return defaultSeeds;
+}
+
+export async function clearSeeds(): Promise<void> {
+  // テスト後のクリーンアップ処理をここに実装
+}
+`;
+  }
+
+  private generateExampleSpec(): string {
+    return `import { test, expect } from '@playwright/test';
+
+test.describe('${this.config.projectName} E2E', () => {
+  test('トップページが表示されること', async ({ page }) => {
+    await page.goto('/');
+    await expect(page).toHaveTitle(/.*/);
+  });
+
+  test('ナビゲーションが動作すること', async ({ page }) => {
+    await page.goto('/');
+    await page.waitForLoadState('networkidle');
+    // TODO: プロジェクト固有のナビゲーションテストを追加
+  });
+});
+`;
+  }
+}

package/scripts/harness/phase2-extensions/infrastructure/adapters/regex-pointer-extractor-adapter.ts

@@ -0,0 +1,53 @@
+/**
+ * @layer infrastructure
+ * @unit phase2-extensions
+ */
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import type { PointerExtractorPort } from '../../domain/ports/pointer-extractor-port.js';
+import { Pointer } from '../../domain/value-objects/pointer.js';
+
+const MARKDOWN_LINK_REGEX = /\[([^\]]+)\]\(([^)]+)\)/g;
+const RELATIVE_PATH_REGEX = /(?:^|\s)((?:docs|scripts)\/[^\s,'")\]]+)/gm;
+
+function isUrlTarget(target: string): boolean {
+  return target.startsWith('http://') || target.startsWith('https://');
+}
+
+export class RegexPointerExtractorAdapter implements PointerExtractorPort {
+  constructor(private readonly projectRoot: string) {}
+
+  async extract(documentPath: string): Promise<Pointer[]> {
+    const content = await fs.readFile(path.resolve(this.projectRoot, documentPath), 'utf8');
+    const pointers: Pointer[] = [];
+    const seen = new Set<string>();
+
+    for (const match of content.matchAll(MARKDOWN_LINK_REGEX)) {
+      const rawText = match[0];
+      const target = match[2]?.trim();
+      if (!target) {
+        continue;
+      }
+      const type = isUrlTarget(target) ? 'url' : 'file-path';
+      const key = `${type}:${target}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        pointers.push(Pointer.create({ type, rawText, target }));
+      }
+    }
+
+    for (const match of content.matchAll(RELATIVE_PATH_REGEX)) {
+      const target = match[1]?.trim();
+      if (!target) {
+        continue;
+      }
+      const key = `file-path:${target}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        pointers.push(Pointer.create({ type: 'file-path', rawText: target, target }));
+      }
+    }
+
+    return pointers;
+  }
+}

package/scripts/harness/phase2-extensions/presentation/formatters/freshness-result-formatter.ts

@@ -0,0 +1,18 @@
+/**
+ * @layer presentation
+ * @unit phase2-extensions
+ */
+import type { CheckDocFreshnessOutput } from '../../application/dto/check-doc-freshness-output.js';
+
+export class FreshnessResultFormatter {
+  formatJson(result: CheckDocFreshnessOutput): string {
+    return JSON.stringify(result, null, 2);
+  }
+
+  formatText(result: CheckDocFreshnessOutput): string {
+    return [
+      `total=${result.summary.total} ok=${result.summary.ok} warn=${result.summary.warn} error=${result.summary.error}`,
+      ...result.results.map((entry) => `${entry.level}: ${entry.documentPath} (${entry.ageInDays}d)`),
+    ].join('\n');
+  }
+}

package/scripts/harness/phase2-extensions/presentation/formatters/pointer-result-formatter.ts

@@ -0,0 +1,18 @@
+/**
+ * @layer presentation
+ * @unit phase2-extensions
+ */
+import type { ValidateDocPointersOutput } from '../../application/dto/validate-doc-pointers-output.js';
+
+export class PointerResultFormatter {
+  formatJson(result: ValidateDocPointersOutput): string {
+    return JSON.stringify(result, null, 2);
+  }
+
+  formatText(result: ValidateDocPointersOutput): string {
+    return [
+      `documents=${result.summary.totalDocuments} pointers=${result.summary.totalPointers} broken=${result.summary.brokenPointers}`,
+      ...result.results.map((entry) => `${entry.isResolvable ? 'ok' : 'broken'}: ${entry.pointerTarget}`),
+    ].join('\n');
+  }
+}

package/scripts/harness/phase2-extensions/presentation/handlers/check-freshness-handler.ts

@@ -0,0 +1,37 @@
+/**
+ * @layer presentation
+ * @unit phase2-extensions
+ */
+import type { CheckDocFreshnessUseCase } from '../../application/usecases/check-doc-freshness-usecase.js';
+import { FreshnessResultFormatter } from '../formatters/freshness-result-formatter.js';
+
+export class CheckFreshnessHandler {
+  private readonly formatter = new FreshnessResultFormatter();
+
+  constructor(private readonly useCase: CheckDocFreshnessUseCase) {}
+
+  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.summary.error > 0 ? 1 : 0,
+      stdout: format === 'json' ? this.formatter.formatJson(result) : this.formatter.formatText(result),
+    };
+  }
+}

package/scripts/harness/phase2-extensions/presentation/handlers/generate-e2e-template-handler.ts

@@ -0,0 +1,43 @@
+/**
+ * @layer presentation
+ * @unit phase2-extensions
+ */
+import * as fs from 'node:fs/promises';
+import type { GenerateE2ETemplateUseCase } from '../../application/usecases/generate-e2e-template-usecase.js';
+
+export class GenerateE2ETemplateHandler {
+  constructor(private readonly useCase: GenerateE2ETemplateUseCase) {}
+
+  async handle(args: string[]): Promise<{ exitCode: number; stdout: string }> {
+    let targetPhase: string | undefined;
+    let outputPath: string | undefined;
+
+    for (let index = 0; index < args.length; index += 1) {
+      const arg = args[index];
+      if (arg === '--phase') {
+        targetPhase = args[index + 1];
+        index += 1;
+      } else if (arg === '--output') {
+        outputPath = args[index + 1];
+        index += 1;
+      }
+    }
+
+    if (!targetPhase) {
+      return {
+        exitCode: 2,
+        stdout: 'missing required --phase',
+      };
+    }
+
+    const result = await this.useCase.execute({ targetPhase, outputPath });
+    if (outputPath) {
+      await fs.writeFile(outputPath, result.templateContent, 'utf8');
+    }
+
+    return {
+      exitCode: result.errors.length > 0 ? 1 : 0,
+      stdout: result.templateContent,
+    };
+  }
+}

package/scripts/harness/phase2-extensions/presentation/handlers/validate-pointers-handler.ts

@@ -0,0 +1,33 @@
+/**
+ * @layer presentation
+ * @unit phase2-extensions
+ */
+import type { ValidateDocPointersUseCase } from '../../application/usecases/validate-doc-pointers-usecase.js';
+import { PointerResultFormatter } from '../formatters/pointer-result-formatter.js';
+
+export class ValidatePointersHandler {
+  private readonly formatter = new PointerResultFormatter();
+
+  constructor(private readonly useCase: ValidateDocPointersUseCase) {}
+
+  async handle(args: string[]): Promise<{ exitCode: number; stdout: string }> {
+    let includeUrlPointers = false;
+    let format: 'text' | 'json' = 'text';
+
+    for (let index = 0; index < args.length; index += 1) {
+      const arg = args[index];
+      if (arg === '--include-urls') {
+        includeUrlPointers = true;
+      } else if (arg === '--format') {
+        format = (args[index + 1] as 'text' | 'json') ?? 'text';
+        index += 1;
+      }
+    }
+
+    const result = await this.useCase.execute({ includeUrlPointers, format });
+    return {
+      exitCode: result.passed ? 0 : 1,
+      stdout: format === 'json' ? this.formatter.formatJson(result) : this.formatter.formatText(result),
+    };
+  }
+}

package/scripts/harness/quick-mode/application/dto/build-relaxation-profile-input.ts

@@ -0,0 +1,12 @@
+/**
+ * @layer application
+ * @unit quick-mode
+ *
+ * BuildRelaxationProfileUseCase の入力 DTO
+ */
+
+import type { QuickModeEligibilityContract } from './quick-mode-eligibility-contract.js';
+
+export interface BuildRelaxationProfileInput {
+  readonly eligibilityContract: QuickModeEligibilityContract;
+}

package/scripts/harness/quick-mode/application/dto/execute-quick-ci-check-input.ts

@@ -0,0 +1,11 @@
+/**
+ * @layer application
+ * @unit quick-mode
+ *
+ * ExecuteQuickCiCheckUseCase の入力 DTO
+ */
+
+export interface ExecuteQuickCiCheckInput {
+  readonly changedFiles?: readonly { filePath: string; changeKind: string }[];
+  readonly dryRun?: boolean;
+}

package/scripts/harness/quick-mode/application/dto/judge-quick-mode-eligibility-input.ts

@@ -0,0 +1,10 @@
+/**
+ * @layer application
+ * @unit quick-mode
+ *
+ * JudgeQuickModeEligibilityUseCase の入力 DTO
+ */
+
+export interface JudgeQuickModeEligibilityInput {
+  readonly changedFiles?: readonly { filePath: string; changeKind: string }[];
+}

package/scripts/harness/quick-mode/application/dto/quick-mode-decision-contract.ts

@@ -0,0 +1,14 @@
+/**
+ * @layer application
+ * @unit quick-mode
+ *
+ * Shared Kernel公開用 readonly DTO（harness-api向け）
+ */
+
+import type { QuickModeEligibilityContract } from './quick-mode-eligibility-contract.js';
+import type { ValidatorRelaxationProfileContract } from './validator-relaxation-profile-contract.js';
+
+export interface QuickModeDecisionContract {
+  readonly eligibility: QuickModeEligibilityContract;
+  readonly relaxationProfile?: ValidatorRelaxationProfileContract;
+}

package/scripts/harness/quick-mode/application/dto/quick-mode-eligibility-contract.ts

@@ -0,0 +1,13 @@
+/**
+ * @layer application
+ * @unit quick-mode
+ *
+ * QuickModeEligibility の公開 DTO
+ */
+
+export interface QuickModeEligibilityContract {
+  readonly eligible: boolean;
+  readonly reason: string;
+  readonly rejectionRule?: 'MIXED_CHANGES' | 'NEW_DOMAIN' | 'API_CONTRACT';
+  readonly rejectedFiles?: readonly { filePath: string; changeKind: string }[];
+}

package/scripts/harness/quick-mode/application/dto/validator-relaxation-profile-contract.ts

@@ -0,0 +1,21 @@
+/**
+ * @layer application
+ * @unit quick-mode
+ *
+ * validator-system向け緩和プロファイル公開 DTO
+ */
+
+export interface ValidatorRelaxationProfileContract {
+  readonly levelDependencyRelaxed: false;
+  readonly l1: { readonly all: true };
+  readonly l2: {
+    readonly maintained: readonly string[];
+    readonly skipped: readonly string[];
+  };
+  readonly l3: {
+    readonly maintained: readonly string[];
+    readonly skipped: readonly string[];
+  };
+  readonly l4: { readonly all: false };
+  readonly phaseExecution: { readonly twoPhaseRequired: false };
+}

package/scripts/harness/quick-mode/application/mappers/quick-mode-decision-contract-mapper.ts

@@ -0,0 +1,73 @@
+/**
+ * @layer application
+ * @unit quick-mode
+ *
+ * QuickModeDecision を QuickModeDecisionContract に投影するMapper
+ */
+
+import type { QuickModeEligibility } from '../../domain/value-objects/quick-mode-eligibility.js';
+import type { ValidatorRelaxationProfile } from '../../domain/value-objects/validator-relaxation-profile.js';
+import type { QuickModeDecision } from '../../domain/value-objects/quick-mode-decision.js';
+import type { QuickModeEligibilityContract } from '../dto/quick-mode-eligibility-contract.js';
+import type { ValidatorRelaxationProfileContract } from '../dto/validator-relaxation-profile-contract.js';
+import type { QuickModeDecisionContract } from '../dto/quick-mode-decision-contract.js';
+
+export class QuickModeDecisionContractMapper {
+  toEligibilityContract(eligibility: QuickModeEligibility): Readonly<QuickModeEligibilityContract> {
+    if (eligibility.isEligible()) {
+      return Object.freeze({
+        eligible: true,
+        reason: eligibility.reason,
+        rejectionRule: undefined,
+        rejectedFiles: undefined,
+      });
+    }
+
+    return Object.freeze({
+      eligible: false,
+      reason: eligibility.reason,
+      rejectionRule: eligibility.rejectionRule,
+      rejectedFiles: eligibility.rejectedFiles?.map((f) => ({
+        filePath: f.filePath,
+        changeKind: f.changeKind,
+      })),
+    });
+  }
+
+  toRelaxationProfileContract(
+    profile: ValidatorRelaxationProfile
+  ): Readonly<ValidatorRelaxationProfileContract> {
+    return Object.freeze({
+      levelDependencyRelaxed: false as const,
+      l1: Object.freeze({ all: true as const }),
+      l2: Object.freeze({
+        maintained: Object.freeze([...profile.l2.maintained]),
+        skipped: Object.freeze([...profile.l2.skipped]),
+      }),
+      l3: Object.freeze({
+        maintained: Object.freeze([...profile.l3.maintained]),
+        skipped: Object.freeze([...profile.l3.skipped]),
+      }),
+      l4: Object.freeze({ all: false as const }),
+      phaseExecution: Object.freeze({ twoPhaseRequired: false as const }),
+    });
+  }
+
+  toDecisionContract(decision: QuickModeDecision): Readonly<QuickModeDecisionContract> {
+    const eligibilityContract = this.toEligibilityContract(decision.eligibility);
+
+    if (!decision.isApproved() || decision.relaxationProfile === undefined) {
+      return Object.freeze({
+        eligibility: eligibilityContract,
+        relaxationProfile: undefined,
+      });
+    }
+
+    const relaxationProfileContract = this.toRelaxationProfileContract(decision.relaxationProfile);
+
+    return Object.freeze({
+      eligibility: eligibilityContract,
+      relaxationProfile: relaxationProfileContract,
+    });
+  }
+}

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

@@ -0,0 +1,8 @@
+/**
+ * @layer application
+ * @unit quick-mode
+ *
+ * Application層のChangedFilesPort（domain portの再エクスポート）
+ */
+
+export type { ChangedFilesPort } from '../../domain/ports/changed-files-port.js';

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

@@ -0,0 +1,13 @@
+/**
+ * @layer application
+ * @unit quick-mode
+ *
+ * Application層のQuickModeConfigPort
+ * UT-JUC テストでの getConfig メソッド名に対応するため独自定義
+ */
+
+import type { QuickModeConfig } from '../../domain/value-objects/quick-mode-config.js';
+
+export interface QuickModeConfigPort {
+  getConfig(): QuickModeConfig | Promise<QuickModeConfig>;
+}

package/scripts/harness/quick-mode/application/ports/validator-execution-port.ts

@@ -0,0 +1,12 @@
+/**
+ * @layer application
+ * @unit quick-mode
+ *
+ * validator-system への緩和実行指示ポート
+ */
+
+import type { ValidatorRelaxationProfileContract } from '../dto/validator-relaxation-profile-contract.js';
+
+export interface ValidatorExecutionPort {
+  executeWithProfile(profile: ValidatorRelaxationProfileContract): Promise<void>;
+}

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

@@ -0,0 +1,11 @@
+/**
+ * @layer application
+ * @unit quick-mode
+ *
+ * Application層のValidatorIdRegistryPort
+ * UT-BUC テストでの getAllIds メソッド名に対応するため独自定義
+ */
+
+export interface ValidatorIdRegistryPort {
+  getAllIds(): readonly string[] | Promise<readonly string[]>;
+}