phasegate 0.15.0

package/scripts/harness/phase-dependency-model/domain/values/phase-customization-policy.ts

@@ -0,0 +1,57 @@
+/**
+ * @layer domain
+ * @unit phase-dependency-model
+ */
+
+import { CustomRule } from './custom-rule.js';
+
+export interface PhaseCustomizationPolicyCreateArgs {
+  readonly preset?: 'default' | 'custom';
+  readonly rules: readonly CustomRule[];
+  readonly overrideEnabled: boolean;
+}
+
+export class PhaseCustomizationPolicy {
+  readonly preset: 'default' | 'custom';
+  readonly rules: readonly CustomRule[];
+  readonly overrideEnabled: boolean;
+
+  private constructor(args: {
+    readonly preset: 'default' | 'custom';
+    readonly rules: readonly CustomRule[];
+    readonly overrideEnabled: boolean;
+  }) {
+    this.preset = args.preset;
+    this.rules = Object.freeze([...args.rules]);
+    this.overrideEnabled = args.overrideEnabled;
+    Object.freeze(this);
+  }
+
+  static create(args: PhaseCustomizationPolicyCreateArgs): PhaseCustomizationPolicy {
+    return new PhaseCustomizationPolicy({
+      preset: args.preset ?? (args.rules.length === 0 ? 'default' : 'custom'),
+      rules: args.rules,
+      overrideEnabled: args.overrideEnabled,
+    });
+  }
+
+  hasRules(): boolean {
+    return this.rules.length > 0;
+  }
+
+  requestsOverride(): boolean {
+    return this.overrideEnabled;
+  }
+
+  equals(other: PhaseCustomizationPolicy): boolean {
+    if (
+      this.preset !== other.preset ||
+      this.overrideEnabled !== other.overrideEnabled ||
+      this.rules.length !== other.rules.length
+    ) {
+      return false;
+    }
+
+    return this.rules.every((rule, index) => rule.equals(other.rules[index]));
+  }
+}

package/scripts/harness/phase-dependency-model/domain/values/phase-dependency.ts

@@ -0,0 +1,62 @@
+/**
+ * @layer domain
+ * @unit phase-dependency-model
+ */
+
+import { PhaseNode } from './phase-node.js';
+
+export type PhaseDependencyType = 'requires' | 'recommends';
+
+export interface PhaseDependencyCreateArgs {
+  readonly from: PhaseNode;
+  readonly to: PhaseNode;
+  readonly type: PhaseDependencyType;
+}
+
+export class InvalidPhaseDependencyError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'InvalidPhaseDependencyError';
+  }
+}
+
+export class PhaseDependency {
+  readonly from: PhaseNode;
+  readonly to: PhaseNode;
+  readonly type: PhaseDependencyType;
+
+  private constructor(args: PhaseDependencyCreateArgs) {
+    this.from = args.from;
+    this.to = args.to;
+    this.type = args.type;
+    Object.freeze(this);
+  }
+
+  static create(args: PhaseDependencyCreateArgs): PhaseDependency {
+    if (args.from.equals(args.to)) {
+      throw new InvalidPhaseDependencyError('自己依存は許可されません');
+    }
+
+    if (args.type !== 'requires' && args.type !== 'recommends') {
+      throw new InvalidPhaseDependencyError(`依存種別が不正です: ${args.type}`);
+    }
+
+    return new PhaseDependency(args);
+  }
+
+  isCrossLevel(): boolean {
+    return this.from.level.value !== this.to.level.value;
+  }
+
+  isLevelTransition(): boolean {
+    return this.isCrossLevel() && this.to.level.value - this.from.level.value === 1;
+  }
+
+  equals(other: PhaseDependency): boolean {
+    return (
+      this.from.equals(other.from) &&
+      this.to.equals(other.to) &&
+      this.type === other.type
+    );
+  }
+}

package/scripts/harness/phase-dependency-model/domain/values/phase-gate-result.ts

@@ -0,0 +1,71 @@
+/**
+ * @layer domain
+ * @unit phase-dependency-model
+ */
+
+export interface PhaseGateResultCreateArgs {
+  readonly passed: boolean;
+  readonly blockers: readonly string[];
+  readonly warnings?: readonly string[];
+  readonly auditPayload?: Record<string, unknown>;
+}
+
+export class PhaseGateResult {
+  readonly passed: boolean;
+  readonly blockers: readonly string[];
+  readonly warnings: readonly string[];
+  readonly auditPayload?: Record<string, unknown>;
+
+  private constructor(args: {
+    readonly passed: boolean;
+    readonly blockers: readonly string[];
+    readonly warnings: readonly string[];
+    readonly auditPayload?: Record<string, unknown>;
+  }) {
+    this.passed = args.passed;
+    this.blockers = Object.freeze([...args.blockers]);
+    this.warnings = Object.freeze([...args.warnings]);
+    this.auditPayload = args.auditPayload;
+    Object.freeze(this);
+  }
+
+  static create(args: PhaseGateResultCreateArgs): PhaseGateResult {
+    if (!args.passed && args.blockers.length === 0) {
+      throw new Error('passed=false の場合はblockersが必要です');
+    }
+
+    return new PhaseGateResult({
+      passed: args.passed,
+      blockers: args.blockers,
+      warnings: args.warnings ?? Object.freeze([]),
+      auditPayload: args.auditPayload,
+    });
+  }
+
+  isBlocked(): boolean {
+    return !this.passed;
+  }
+
+  hasAuditTrail(): boolean {
+    return this.auditPayload !== undefined;
+  }
+
+  equals(other: PhaseGateResult): boolean {
+    const auditEquals =
+      JSON.stringify(this.auditPayload ?? null) === JSON.stringify(other.auditPayload ?? null);
+
+    if (
+      this.passed !== other.passed ||
+      this.blockers.length !== other.blockers.length ||
+      this.warnings.length !== other.warnings.length ||
+      !auditEquals
+    ) {
+      return false;
+    }
+
+    return (
+      this.blockers.every((entry, index) => entry === other.blockers[index]) &&
+      this.warnings.every((entry, index) => entry === other.warnings[index])
+    );
+  }
+}

package/scripts/harness/phase-dependency-model/domain/values/phase-level.ts

@@ -0,0 +1,42 @@
+/**
+ * @layer domain
+ * @unit phase-dependency-model
+ */
+
+export type PhaseLevelValue = 1 | 2 | 3;
+
+export class InvalidPhaseLevelError extends Error {
+  constructor(value: number) {
+    super(`PhaseLevelが不正です: ${value}`);
+    this.name = 'InvalidPhaseLevelError';
+  }
+}
+
+export class PhaseLevel {
+  readonly value: PhaseLevelValue;
+
+  private constructor(value: PhaseLevelValue) {
+    this.value = value;
+    Object.freeze(this);
+  }
+
+  static create(value: number): PhaseLevel {
+    if (!Number.isInteger(value) || value < 1 || value > 3) {
+      throw new InvalidPhaseLevelError(value);
+    }
+
+    return new PhaseLevel(value as PhaseLevelValue);
+  }
+
+  isHigherThan(other: PhaseLevel): boolean {
+    return this.value > other.value;
+  }
+
+  isPrerequisiteOf(other: PhaseLevel): boolean {
+    return this.value < other.value;
+  }
+
+  equals(other: PhaseLevel): boolean {
+    return this.value === other.value;
+  }
+}

package/scripts/harness/phase-dependency-model/domain/values/phase-node.ts

@@ -0,0 +1,72 @@
+/**
+ * @layer domain
+ * @unit phase-dependency-model
+ */
+
+import { Artifact } from './artifact.js';
+import { PhaseLevel } from './phase-level.js';
+
+export interface PhaseNodeCreateArgs {
+  readonly skillName: string;
+  readonly level: PhaseLevel;
+  readonly artifacts: readonly Artifact[];
+}
+
+export class PhaseNode {
+  readonly skillName: string;
+  readonly level: PhaseLevel;
+  readonly artifacts: readonly Artifact[];
+
+  private constructor(args: PhaseNodeCreateArgs) {
+    this.skillName = args.skillName.trim();
+    this.level = args.level;
+    this.artifacts = Object.freeze([...args.artifacts]);
+    Object.freeze(this);
+  }
+
+  static create(args: PhaseNodeCreateArgs): PhaseNode {
+    const skillName = args.skillName.trim();
+
+    if (skillName.length === 0) {
+      throw new Error('PhaseNode.skillNameは空文字を許可しません');
+    }
+
+    if (
+      args.level.value === 3 &&
+      args.artifacts.length > 0 &&
+      args.artifacts.some((artifact) => !artifact.path.includes('{storyId}'))
+    ) {
+      throw new Error('Level 3のArtifactには{storyId}が必要です');
+    }
+
+    return new PhaseNode({
+      skillName,
+      level: args.level,
+      artifacts: args.artifacts,
+    });
+  }
+
+  nodeKey(): string {
+    return `${this.level.value}:${this.skillName}`;
+  }
+
+  planArtifacts(): readonly Artifact[] {
+    return Object.freeze(this.artifacts.filter((artifact) => artifact.isPlanArtifact()));
+  }
+
+  requiredArtifacts(): readonly Artifact[] {
+    return Object.freeze(this.artifacts.filter((artifact) => artifact.required));
+  }
+
+  equals(other: PhaseNode): boolean {
+    if (
+      this.skillName !== other.skillName ||
+      !this.level.equals(other.level) ||
+      this.artifacts.length !== other.artifacts.length
+    ) {
+      return false;
+    }
+
+    return this.artifacts.every((artifact, index) => artifact.equals(other.artifacts[index]));
+  }
+}

package/scripts/harness/phase-dependency-model/domain/values/plan-evidence.ts

@@ -0,0 +1,43 @@
+/**
+ * @layer domain
+ * @unit phase-dependency-model
+ */
+
+export interface PlanEvidenceCreateArgs {
+  readonly exists: boolean;
+  readonly qaComplete: boolean;
+  readonly planningModeMatch: boolean;
+}
+
+export class PlanEvidence {
+  readonly exists: boolean;
+  readonly qaComplete: boolean;
+  readonly planningModeMatch: boolean;
+
+  private constructor(args: PlanEvidenceCreateArgs) {
+    this.exists = args.exists;
+    this.qaComplete = args.qaComplete;
+    this.planningModeMatch = args.planningModeMatch;
+    Object.freeze(this);
+  }
+
+  static create(args: PlanEvidenceCreateArgs): PlanEvidence {
+    if (!args.exists && (args.qaComplete || args.planningModeMatch)) {
+      throw new Error('存在しないplan文書にQA充足は設定できません');
+    }
+
+    return new PlanEvidence(args);
+  }
+
+  blocksPhaseTransition(): boolean {
+    return !this.exists || !this.qaComplete || !this.planningModeMatch;
+  }
+
+  equals(other: PlanEvidence): boolean {
+    return (
+      this.exists === other.exists &&
+      this.qaComplete === other.qaComplete &&
+      this.planningModeMatch === other.planningModeMatch
+    );
+  }
+}

package/scripts/harness/phase-dependency-model/domain/values/planning-mode.ts

@@ -0,0 +1,60 @@
+/**
+ * @layer domain
+ * @unit phase-dependency-model
+ */
+
+export type PlanningModeValue = 'interactive' | 'embedded-qa';
+
+export class InvalidPlanningModeError extends Error {
+  constructor(value: string) {
+    super(`PlanningModeが不正です: ${value}`);
+    this.name = 'InvalidPlanningModeError';
+  }
+}
+
+export class PlanningMode {
+  readonly value: PlanningModeValue;
+
+  private constructor(value: PlanningModeValue) {
+    this.value = value;
+    Object.freeze(this);
+  }
+
+  static create(value: string): PlanningMode {
+    if (value !== 'interactive' && value !== 'embedded-qa') {
+      throw new InvalidPlanningModeError(value);
+    }
+
+    return new PlanningMode(value);
+  }
+
+  static fromConfig(
+    config:
+      | string
+      | {
+          readonly default?: string;
+          readonly mode?: string;
+          readonly planningMode?: string;
+        },
+  ): PlanningMode {
+    if (typeof config === 'string') {
+      return PlanningMode.create(config);
+    }
+
+    const value = config.default ?? config.mode ?? config.planningMode;
+    // 値が未設定の場合はデフォルト値 'interactive' を使用する
+    return PlanningMode.create(value ?? 'interactive');
+  }
+
+  requiresAnsweredQa(): boolean {
+    return this.value === 'embedded-qa';
+  }
+
+  requiresQaSection(): boolean {
+    return this.value === 'interactive';
+  }
+
+  equals(other: PlanningMode): boolean {
+    return this.value === other.value;
+  }
+}

package/scripts/harness/phase-dependency-model/index.ts

@@ -0,0 +1,13 @@
+/**
+ * @layer public-api
+ * @unit phase-dependency-model
+ *
+ * phase-dependency-model ユニットのバレルエクスポート。
+ */
+
+// Composition Root
+export { createPhaseDependencyModelModule } from './composition-root.js';
+export type { PhaseDependencyModelConfig } from './composition-root.js';
+
+// Presentation — CLI handlers
+export { CheckPhaseGateCommandHandler } from './presentation/cli/check-phase-gate-command-handler.js';

package/scripts/harness/phase-dependency-model/infrastructure/config/harness-config-phase-config-provider.ts

@@ -0,0 +1,98 @@
+/**
+ * @layer infrastructure
+ * @unit phase-dependency-model
+ */
+
+import type { PhaseConfigProviderPort } from '../../domain/ports/phase-config-provider-port.js';
+import { PlanningMode } from '../../domain/values/planning-mode.js';
+import { PhaseCustomizationPolicy } from '../../domain/values/phase-customization-policy.js';
+import { CustomRule } from '../../domain/values/custom-rule.js';
+
+export interface PhaseConfigSection {
+  readonly planningMode?:
+    | string
+    | {
+        readonly default?: string;
+        readonly mode?: string;
+        readonly planningMode?: string;
+        readonly overrides?: Record<string, string>;
+      };
+  readonly customization?: {
+    readonly preset?: 'default' | 'custom';
+    readonly overrideEnabled?: boolean;
+    readonly rules?: ReadonlyArray<{
+      readonly targetPhase: string;
+      readonly condition: string;
+      readonly action: readonly string[];
+    }>;
+  };
+  readonly reportingOutputDir?: string;
+}
+
+export interface HarnessConfigPhaseConfigProviderDeps {
+  readonly config: PhaseConfigSection;
+  readonly defaultOutputDir: string;
+}
+
+export class HarnessConfigPhaseConfigProvider
+  implements PhaseConfigProviderPort
+{
+  private readonly config: PhaseConfigSection;
+  private readonly defaultOutputDir: string;
+
+  constructor(deps: HarnessConfigPhaseConfigProviderDeps) {
+    this.config = deps.config;
+    this.defaultOutputDir = deps.defaultOutputDir;
+  }
+
+  async getPlanningMode(scope: {
+    unitId?: string;
+    storyId?: string;
+  }): Promise<PlanningMode> {
+    const planningModeConfig = this.config.planningMode;
+
+    if (planningModeConfig === undefined) {
+      return PlanningMode.create('interactive');
+    }
+
+    if (typeof planningModeConfig === 'string') {
+      return PlanningMode.create(planningModeConfig);
+    }
+
+    if (scope.unitId && planningModeConfig.overrides?.[scope.unitId]) {
+      return PlanningMode.create(planningModeConfig.overrides[scope.unitId]);
+    }
+
+    return PlanningMode.fromConfig(planningModeConfig);
+  }
+
+  async getCustomizationPolicy(): Promise<PhaseCustomizationPolicy> {
+    const customization = this.config.customization;
+
+    if (!customization) {
+      return PhaseCustomizationPolicy.create({
+        preset: 'default',
+        rules: [],
+        overrideEnabled: false,
+      });
+    }
+
+    const rules = (customization.rules ?? []).map((rule) =>
+      CustomRule.create({
+        targetPhase: rule.targetPhase,
+        condition: rule.condition,
+        action: [...rule.action],
+      }),
+    );
+
+    return PhaseCustomizationPolicy.create({
+      preset: customization.preset,
+      rules,
+      overrideEnabled: customization.overrideEnabled ?? false,
+    });
+  }
+
+  async getReportingOutputDir(): Promise<string> {
+    return this.config.reportingOutputDir ?? this.defaultOutputDir;
+  }
+}

package/scripts/harness/phase-dependency-model/infrastructure/filesystem/file-system-artifact-existence-checker.ts

@@ -0,0 +1,54 @@
+/**
+ * @layer infrastructure
+ * @unit phase-dependency-model
+ */
+
+import { access } from 'node:fs/promises';
+import * as path from 'node:path';
+import type { ArtifactExistenceCheckerPort } from '../../domain/ports/artifact-existence-checker-port.js';
+import type { Artifact } from '../../domain/values/artifact.js';
+
+export interface FileSystemArtifactExistenceCheckerDeps {
+  readonly rootDir: string;
+}
+
+export class FileSystemArtifactExistenceChecker
+  implements ArtifactExistenceCheckerPort
+{
+  private readonly rootDir: string;
+
+  constructor(deps: FileSystemArtifactExistenceCheckerDeps) {
+    this.rootDir = deps.rootDir;
+  }
+
+  async checkAll(
+    artifacts: readonly Artifact[],
+    scope: { unitId?: string; storyId?: string },
+  ): Promise<ReadonlyMap<string, boolean>> {
+    const results = new Map<string, boolean>();
+
+    for (const artifact of artifacts) {
+      let resolvedPath: string;
+      try {
+        resolvedPath = artifact.resolve(scope);
+      } catch {
+        results.set(artifact.path, false);
+        continue;
+      }
+      const absolutePath = path.join(this.rootDir, resolvedPath);
+      const exists = await this.fileExists(absolutePath);
+      results.set(resolvedPath, exists);
+    }
+
+    return results;
+  }
+
+  private async fileExists(filePath: string): Promise<boolean> {
+    try {
+      await access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}