phasegate 0.15.0

package/scripts/harness/traceability-model/infrastructure/parsers/source-metadata-parser.ts

@@ -0,0 +1,103 @@
+/**
+ * @layer infrastructure
+ * @unit traceability-model
+ *
+ * TypeScript/TSX/JS/JSXの行コメントまたはJSDocから @unit / @layer / @story を抽出する行指向パーサー
+ */
+import type { MetadataTagLike } from '../../domain/ports/metadata-reader-port.js';
+
+const UNIT_TAG_PATTERN = /^\s*(?:\/\/|\*)\s*@unit\s+(.+)$/;
+const LAYER_TAG_PATTERN = /^\s*(?:\/\/|\*)\s*@layer\s+(.+)$/;
+const STORY_TAG_PATTERN = /^\s*(?:\/\/|\*)\s*@story\s+(.+)$/;
+const STORY_ID_TAG_PATTERN = /^\s*(?:\/\/|\*)\s*@story-id\s+(.+)$/;
+
+export interface ParsedMetadataTag {
+  readonly type: string;
+  readonly value: string;
+  readonly lineNumber: number;
+}
+
+/**
+ * 実装ファイル向けに @unit / @layer / @story-id を抽出する
+ */
+export function parseImplementationTags(content: string): readonly ParsedMetadataTag[] {
+  const lines = content.split('\n');
+  const tags: ParsedMetadataTag[] = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNumber = i + 1;
+
+    const unitMatch = UNIT_TAG_PATTERN.exec(line);
+    if (unitMatch) {
+      tags.push({ type: '@unit', value: unitMatch[1].trim(), lineNumber });
+    }
+
+    const layerMatch = LAYER_TAG_PATTERN.exec(line);
+    if (layerMatch) {
+      tags.push({ type: '@layer', value: layerMatch[1].trim(), lineNumber });
+    }
+
+    const storyIdMatch = STORY_ID_TAG_PATTERN.exec(line);
+    if (storyIdMatch) {
+      tags.push({ type: '@story-id', value: storyIdMatch[1].trim(), lineNumber });
+    }
+  }
+
+  return Object.freeze([...tags]);
+}
+
+/**
+ * テストファイル向けに @story を抽出する
+ */
+export function parseTestTags(content: string): readonly ParsedMetadataTag[] {
+  const lines = content.split('\n');
+  const tags: ParsedMetadataTag[] = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNumber = i + 1;
+
+    const storyMatch = STORY_TAG_PATTERN.exec(line);
+    if (storyMatch) {
+      tags.push({ type: '@story', value: storyMatch[1].trim(), lineNumber });
+    }
+  }
+
+  return Object.freeze([...tags]);
+}
+
+/**
+ * 全タグ種別を抽出する（汎用）
+ */
+export function parseAllTags(content: string): readonly ParsedMetadataTag[] {
+  const lines = content.split('\n');
+  const tags: ParsedMetadataTag[] = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNumber = i + 1;
+
+    const unitMatch = UNIT_TAG_PATTERN.exec(line);
+    if (unitMatch) {
+      tags.push({ type: '@unit', value: unitMatch[1].trim(), lineNumber });
+    }
+
+    const layerMatch = LAYER_TAG_PATTERN.exec(line);
+    if (layerMatch) {
+      tags.push({ type: '@layer', value: layerMatch[1].trim(), lineNumber });
+    }
+
+    const storyIdMatch = STORY_ID_TAG_PATTERN.exec(line);
+    if (storyIdMatch) {
+      tags.push({ type: '@story-id', value: storyIdMatch[1].trim(), lineNumber });
+    }
+
+    const storyMatch = STORY_TAG_PATTERN.exec(line);
+    if (storyMatch) {
+      tags.push({ type: '@story', value: storyMatch[1].trim(), lineNumber });
+    }
+  }
+
+  return Object.freeze([...tags]);
+}

package/scripts/harness/traceability-model/infrastructure/parsers/story-catalog-parser.ts

@@ -0,0 +1,78 @@
+/**
+ * @layer infrastructure
+ * @unit traceability-model
+ *
+ * docs/product/user_stories.md から正規StoryId一覧と旧US対応表を抽出するパーサー
+ */
+
+export interface ParsedStoryCatalog {
+  readonly storyIds: readonly string[];
+  readonly aliasMap: ReadonlyMap<string, string>;
+}
+
+const STORY_ID_LINE_PATTERN = /\bH[0-9]{2}-[0-9]{2}\b/g;
+const TABLE_ALIAS_PATTERN =
+  /\|\s*(H[0-9]{2}-[0-9]{2})\s*\|.*?\|\s*(US-[0-9]{3})\s*\|/g;
+const INLINE_ALIAS_PATTERN =
+  /(H[0-9]{2}-[0-9]{2}).*?旧US\s*[:：]\s*(US-[0-9]{3})/g;
+
+function execAll(pattern: RegExp, text: string): RegExpExecArray[] {
+  const results: RegExpExecArray[] = [];
+  let match: RegExpExecArray | null;
+  // Reset lastIndex to ensure clean iteration
+  pattern.lastIndex = 0;
+  while ((match = pattern.exec(text)) !== null) {
+    results.push(match);
+  }
+  return results;
+}
+
+/**
+ * Markdown文書からStoryId一覧とレガシーエイリアスマップを抽出する。
+ * 表形式・見出し形式の両方に対応する。
+ */
+export function parseStoryCatalog(content: string): ParsedStoryCatalog {
+  const storyIdSet = new Set<string>();
+  const aliasMap = new Map<string, string>();
+
+  // 正規StoryIdを収集
+  const lines = content.split('\n');
+  for (const line of lines) {
+    const matches = execAll(STORY_ID_LINE_PATTERN, line);
+    for (let j = 0; j < matches.length; j++) {
+      storyIdSet.add(matches[j][0]);
+    }
+  }
+
+  // テーブル形式: | H03-01 | ... | US-001 |
+  const tableMatches = execAll(TABLE_ALIAS_PATTERN, content);
+  for (let i = 0; i < tableMatches.length; i++) {
+    aliasMap.set(tableMatches[i][2], tableMatches[i][1]);
+  }
+
+  // インライン形式: H03-01 ... 旧US: US-001
+  const inlineMatches = execAll(INLINE_ALIAS_PATTERN, content);
+  for (let i = 0; i < inlineMatches.length; i++) {
+    aliasMap.set(inlineMatches[i][2], inlineMatches[i][1]);
+  }
+
+  // 前後行コンテキスト形式: H03-01 の直後に 旧US: US-001
+  for (let i = 0; i < lines.length; i++) {
+    const storyIdMatch = /\b(H[0-9]{2}-[0-9]{2})\b/.exec(lines[i]);
+    if (storyIdMatch) {
+      const nextLine = i + 1 < lines.length ? lines[i + 1] : '';
+      const legacyMatch = /旧US\s*[:：]\s*(US-[0-9]{3})/.exec(nextLine);
+      if (legacyMatch) {
+        aliasMap.set(legacyMatch[1], storyIdMatch[1]);
+      }
+    }
+  }
+
+  const storyIds: string[] = [];
+  storyIdSet.forEach((id) => storyIds.push(id));
+
+  return {
+    storyIds: Object.freeze(storyIds),
+    aliasMap,
+  };
+}

package/scripts/harness/traceability-model/presentation/cli/validate-metadata-command-handler.ts

@@ -0,0 +1,87 @@
+/**
+ * @layer presentation
+ * @unit traceability-model
+ */
+
+import type { ValidateImplementationMetadataUseCase } from '../../application/usecases/validate-implementation-metadata-usecase.js';
+import type { MetadataValidationOutput } from '../../application/dto/metadata-validation-output.js';
+import type { ProjectRelativePath } from '../../domain/value-objects/project-relative-path.js';
+
+export interface ValidateMetadataCommandInput {
+  readonly filePaths: readonly string[];
+  readonly json?: boolean;
+}
+
+export interface ValidateMetadataCommandOutput {
+  readonly exitCode: 0 | 1 | 2;
+  readonly results: readonly MetadataValidationOutput[];
+  readonly text: string;
+}
+
+type PathFactory = (value: string) => ProjectRelativePath;
+
+export interface ValidateMetadataCommandHandlerDeps {
+  readonly validateImplementationMetadataUseCase: Pick<
+    ValidateImplementationMetadataUseCase,
+    'execute'
+  >;
+  readonly createProjectRelativePath: PathFactory;
+}
+
+export class ValidateMetadataCommandHandler {
+  private readonly useCase: Pick<ValidateImplementationMetadataUseCase, 'execute'>;
+  private readonly createPath: PathFactory;
+
+  constructor(deps: ValidateMetadataCommandHandlerDeps) {
+    this.useCase = deps.validateImplementationMetadataUseCase;
+    this.createPath = deps.createProjectRelativePath;
+  }
+
+  async execute(
+    input: ValidateMetadataCommandInput,
+  ): Promise<Readonly<ValidateMetadataCommandOutput>> {
+    if (input.filePaths.length === 0) {
+      return Object.freeze({
+        exitCode: 2,
+        results: Object.freeze([]),
+        text: 'Error: no file paths specified',
+      });
+    }
+
+    try {
+      const paths = input.filePaths.map((p) => this.createPath(p));
+      const results = await this.useCase.execute(paths);
+      const hasFailures = results.some((r) => !r.valid);
+      const text = input.json
+        ? JSON.stringify({ results }, null, 2)
+        : this.formatText(results);
+
+      return Object.freeze({
+        exitCode: hasFailures ? 1 : 0,
+        results,
+        text,
+      });
+    } catch {
+      return Object.freeze({
+        exitCode: 2,
+        results: Object.freeze([]),
+        text: 'Error: metadata validation failed unexpectedly',
+      });
+    }
+  }
+
+  private formatText(results: readonly MetadataValidationOutput[]): string {
+    const lines: string[] = [];
+    for (const r of results) {
+      const status = r.valid ? 'PASS' : 'FAIL';
+      lines.push(`[${status}] ${r.filePath}`);
+      for (const e of r.errors) {
+        lines.push(`  ERROR: ${e.message}`);
+      }
+      for (const w of r.warnings) {
+        lines.push(`  WARN: ${w.message}`);
+      }
+    }
+    return lines.join('\n');
+  }
+}

package/scripts/harness/validator-system/application/dto/aggregate-results-input.ts

@@ -0,0 +1,12 @@
+/**
+ * @layer application
+ * @unit validator-system
+ *
+ * AggregateResultsInput — H08-05 UseCase入力DTO
+ */
+import type { ValidationResultContract } from './validation-result-contract.js';
+
+export interface AggregateResultsInput {
+  readonly results: readonly ValidationResultContract[];
+  readonly failOnWarning?: boolean;
+}

package/scripts/harness/validator-system/application/dto/aggregated-validation-report.ts

@@ -0,0 +1,28 @@
+/**
+ * @layer application
+ * @unit validator-system
+ *
+ * AggregatedValidationReport — 統合集約レポートDTO
+ */
+import type { ValidationResultContract } from './validation-result-contract.js';
+
+export interface AggregatedValidationReport {
+  readonly overallPassed: boolean;
+  readonly totalValidators: number;
+  readonly passedValidators: number;
+  readonly failedValidators: number;
+  readonly skippedValidators: number;
+  readonly allErrors: readonly {
+    readonly code: string;
+    readonly severity: string;
+    readonly message: string;
+    readonly suggestion: string;
+    [key: string]: unknown;
+  }[];
+  readonly summary: {
+    readonly totalErrors: number;
+    readonly totalWarnings: number;
+    readonly errorsByLayer: Record<'L2' | 'L3' | 'L4', number>;
+  };
+  readonly results: readonly ValidationResultContract[];
+}

package/scripts/harness/validator-system/application/dto/run-full-validation-input.ts

@@ -0,0 +1,16 @@
+/**
+ * @layer application
+ * @unit validator-system
+ *
+ * RunFullValidationInput — H08-06 UseCase入力DTO
+ */
+export interface RunFullValidationInput {
+  readonly targetPaths: readonly string[];
+  readonly unitName: string;
+  readonly currentPhase: string;
+  readonly targetUnits?: readonly string[];
+  readonly includeL4?: boolean;
+  readonly failOnWarning?: boolean;
+  readonly coverageReportPath?: string;
+  readonly requirementMatrixPath?: string;
+}

package/scripts/harness/validator-system/application/dto/run-l0-validators-input.ts

@@ -0,0 +1,9 @@
+/**
+ * @layer application
+ * @unit validator-system
+ *
+ * RunL0ValidatorsInput — L0バリデータ実行 UseCase入力DTO
+ */
+export interface RunL0ValidatorsInput {
+  readonly validatorIds?: readonly string[];
+}

package/scripts/harness/validator-system/application/dto/run-l1-validators-input.ts

@@ -0,0 +1,12 @@
+/**
+ * @layer application
+ * @unit validator-system
+ *
+ * RunL1ValidatorsInput DTO — H08-07/H08-08: L1バリデータ実行入力
+ */
+export interface RunL1ValidatorsInput {
+  readonly targetPaths?: readonly string[];
+  readonly validatorIds?: readonly string[];
+}
+
+// @story-id H08-07

package/scripts/harness/validator-system/application/dto/run-l2-validators-input.ts

@@ -0,0 +1,12 @@
+/**
+ * @layer application
+ * @unit validator-system
+ *
+ * RunL2ValidatorsInput — H08-01 UseCase入力DTO
+ */
+export interface RunL2ValidatorsInput {
+  readonly validatorIds?: readonly string[];
+  readonly targetPaths: readonly string[];
+  readonly unitName: string;
+  readonly currentPhase: string;
+}

package/scripts/harness/validator-system/application/dto/run-l3-validators-input.ts

@@ -0,0 +1,12 @@
+/**
+ * @layer application
+ * @unit validator-system
+ *
+ * RunL3ValidatorsInput — H08-02 UseCase入力DTO
+ */
+export interface RunL3ValidatorsInput {
+  readonly validatorIds?: readonly string[];
+  readonly targetPaths: readonly string[];
+  readonly coverageReportPath?: string;
+  readonly requirementMatrixPath?: string;
+}

package/scripts/harness/validator-system/application/dto/run-l4-validators-input.ts

@@ -0,0 +1,11 @@
+/**
+ * @layer application
+ * @unit validator-system
+ *
+ * RunL4ValidatorsInput — H08-03 UseCase入力DTO
+ */
+export interface RunL4ValidatorsInput {
+  readonly validatorIds?: readonly string[];
+  readonly targetUnits?: readonly string[];
+  readonly strictMode?: boolean;
+}

package/scripts/harness/validator-system/application/dto/run-quick-mode-input.ts

@@ -0,0 +1,14 @@
+/**
+ * @layer application
+ * @unit validator-system
+ *
+ * RunQuickModeInput — H08-04 UseCase入力DTO
+ */
+import type { ValidatorRelaxationProfile } from './validator-relaxation-profile.js';
+
+export interface RunQuickModeInput {
+  readonly relaxationProfile: ValidatorRelaxationProfile;
+  readonly targetPaths: readonly string[];
+  readonly unitName: string;
+  readonly currentPhase: string;
+}

package/scripts/harness/validator-system/application/dto/validation-result-contract.ts

@@ -0,0 +1,21 @@
+/**
+ * @layer application
+ * @unit validator-system
+ *
+ * ValidationResultContract — 公開契約DTO
+ * H08-01〜H08-06が生成し、harness-api・quick-modeが消費する
+ */
+
+export interface ValidationResultContract {
+  readonly validatorId: string;
+  readonly passed: boolean;
+  readonly errors: readonly {
+    readonly code: string;
+    readonly severity: string;
+    readonly message: string;
+    readonly suggestion: string;
+    [key: string]: unknown;
+  }[];
+  readonly durationMs: number;
+  readonly skipped?: boolean;
+}

package/scripts/harness/validator-system/application/dto/validator-relaxation-profile.ts

@@ -0,0 +1,21 @@
+/**
+ * @layer application
+ * @unit validator-system
+ *
+ * ValidatorRelaxationProfile — quick-mode 緩和プロファイルDTO
+ */
+
+export interface ValidatorRelaxationProfile {
+  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/validator-system/application/mappers/validation-result-contract-mapper.ts

@@ -0,0 +1,29 @@
+/**
+ * @layer application
+ * @unit validator-system
+ *
+ * ValidationResultContractMapper — ValidationResult → Contract変換
+ */
+import type { ValidationResult } from '../../domain/value-objects/validation-result.js';
+import type { ValidationResultContract } from '../dto/validation-result-contract.js';
+
+export class ValidationResultContractMapper {
+  toContract(result: ValidationResult): ValidationResultContract {
+    return {
+      validatorId: result.validatorId.value,
+      passed: result.passed,
+      errors: result.errors.map((e) => ({
+        code: typeof e.code === 'string' ? e.code : e.code.toString(),
+        severity: typeof e.severity === 'string' ? e.severity : e.severity.toString(),
+        message: e.message,
+        suggestion: e.suggestion,
+      })),
+      durationMs: result.durationMs,
+      skipped: result.skipped,
+    };
+  }
+
+  toContracts(results: readonly ValidationResult[]): readonly ValidationResultContract[] {
+    return results.map((r) => this.toContract(r));
+  }
+}

package/scripts/harness/validator-system/application/use-cases/aggregate-validation-results-usecase.ts

@@ -0,0 +1,87 @@
+/**
+ * @layer application
+ * @unit validator-system
+ *
+ * AggregateValidationResultsUseCase — H08-05: バリデータ結果統合集約
+ */
+import type { ValidationResultContract } from '../dto/validation-result-contract.js';
+import type { AggregateResultsInput } from '../dto/aggregate-results-input.js';
+import type { AggregatedValidationReport } from '../dto/aggregated-validation-report.js';
+
+export class AggregateValidationResultsUseCase {
+  execute(input: AggregateResultsInput): AggregatedValidationReport {
+    const { results, failOnWarning = false } = input;
+
+    let passedValidators = 0;
+    let failedValidators = 0;
+    let skippedValidators = 0;
+    const allErrors: {
+      code: string;
+      severity: string;
+      message: string;
+      suggestion: string;
+      [key: string]: unknown;
+    }[] = [];
+    let totalErrors = 0;
+    let totalWarnings = 0;
+    const errorsByLayer: Record<'L2' | 'L3' | 'L4', number> = { L2: 0, L3: 0, L4: 0 };
+
+    for (const result of results) {
+      if (result.skipped) {
+        skippedValidators++;
+        continue;
+      }
+
+      const hasWarnings = result.errors.some((e) => e.severity === 'warning');
+      const hasFail = !result.passed || (failOnWarning && hasWarnings);
+
+      if (hasFail) {
+        failedValidators++;
+      } else {
+        passedValidators++;
+      }
+
+      for (const error of result.errors) {
+        const errorEntry = {
+          code: error.code,
+          severity: error.severity,
+          message: error.message,
+          suggestion: error.suggestion,
+        };
+        allErrors.push(errorEntry);
+
+        if (error.severity === 'warning') {
+          totalWarnings++;
+        } else {
+          totalErrors++;
+        }
+
+        // レイヤー別集計
+        const code = error.code;
+        if (code.startsWith('L2-')) errorsByLayer.L2++;
+        else if (code.startsWith('L3-')) errorsByLayer.L3++;
+        else if (code.startsWith('L4-')) errorsByLayer.L4++;
+      }
+    }
+
+    const overallPassed = failedValidators === 0;
+    const totalValidators = passedValidators + failedValidators + skippedValidators;
+
+    const report: AggregatedValidationReport = Object.freeze({
+      overallPassed,
+      totalValidators,
+      passedValidators,
+      failedValidators,
+      skippedValidators,
+      allErrors: Object.freeze(allErrors),
+      summary: Object.freeze({
+        totalErrors,
+        totalWarnings,
+        errorsByLayer: Object.freeze(errorsByLayer),
+      }),
+      results: Object.freeze([...results]),
+    });
+
+    return report;
+  }
+}

package/scripts/harness/validator-system/application/use-cases/run-full-validation-usecase.ts

@@ -0,0 +1,63 @@
+/**
+ * @layer application
+ * @unit validator-system
+ *
+ * RunFullValidationUseCase — H08-06: フルバリデーション実行
+ */
+import type { RunFullValidationInput } from '../dto/run-full-validation-input.js';
+import type { AggregatedValidationReport } from '../dto/aggregated-validation-report.js';
+import type { RunL2ValidatorsUseCase } from './run-l2-validators-usecase.js';
+import type { RunL3ValidatorsUseCase } from './run-l3-validators-usecase.js';
+import type { RunL4ValidatorsUseCase } from './run-l4-validators-usecase.js';
+import type { AggregateValidationResultsUseCase } from './aggregate-validation-results-usecase.js';
+
+export interface RunFullValidationUseCaseDeps {
+  runL2ValidatorsUseCase: RunL2ValidatorsUseCase;
+  runL3ValidatorsUseCase: RunL3ValidatorsUseCase;
+  runL4ValidatorsUseCase: RunL4ValidatorsUseCase;
+  aggregateValidationResultsUseCase: AggregateValidationResultsUseCase;
+}
+
+export class RunFullValidationUseCase {
+  private readonly l2UseCase: RunL2ValidatorsUseCase;
+  private readonly l3UseCase: RunL3ValidatorsUseCase;
+  private readonly l4UseCase: RunL4ValidatorsUseCase;
+  private readonly aggregateUseCase: AggregateValidationResultsUseCase;
+
+  constructor(deps: RunFullValidationUseCaseDeps) {
+    this.l2UseCase = deps.runL2ValidatorsUseCase;
+    this.l3UseCase = deps.runL3ValidatorsUseCase;
+    this.l4UseCase = deps.runL4ValidatorsUseCase;
+    this.aggregateUseCase = deps.aggregateValidationResultsUseCase;
+  }
+
+  async execute(input: RunFullValidationInput): Promise<AggregatedValidationReport> {
+    const includeL4 = input.includeL4 !== false;
+
+    const l2Results = await this.l2UseCase.execute({
+      targetPaths: input.targetPaths,
+      unitName: input.unitName,
+      currentPhase: input.currentPhase,
+    });
+
+    const l3Results = await this.l3UseCase.execute({
+      targetPaths: input.targetPaths,
+      coverageReportPath: input.coverageReportPath,
+      requirementMatrixPath: input.requirementMatrixPath,
+    });
+
+    let l4Results: readonly { validatorId: string; passed: boolean; errors: readonly { code: string; severity: string; message: string; suggestion: string; [key: string]: unknown }[]; durationMs: number; skipped?: boolean }[] = [];
+    if (includeL4) {
+      l4Results = await this.l4UseCase.execute({
+        targetUnits: input.targetUnits,
+      });
+    }
+
+    const allResults = [...l2Results, ...l3Results, ...l4Results];
+
+    return this.aggregateUseCase.execute({
+      results: allResults,
+      failOnWarning: input.failOnWarning,
+    });
+  }
+}