phasegate 0.15.0

package/scripts/harness/config-foundation/domain/harness-config.ts

@@ -0,0 +1,373 @@
+/**
+ * @layer domain
+ * @unit config-foundation
+ */
+import { ConfigFoundationDomainError } from './errors/config-foundation-domain-error.js';
+import { ConfigValidationError } from './errors/config-validation-error.js';
+import { UnsupportedFeatureError } from './errors/unsupported-feature-error.js';
+import { LayersConfig } from './value-objects/layers-config.js';
+import { PathsConfig } from './value-objects/paths-config.js';
+import { PhaseDependenciesConfig } from './value-objects/phase-dependencies-config.js';
+import { PlanningModeConfig } from './value-objects/planning-mode-config.js';
+import { ProjectConfig } from './value-objects/project-config.js';
+import { QuickModeConfig } from './value-objects/quick-mode-config.js';
+import { ReportingConfig } from './value-objects/reporting-config.js';
+import { HarnessesConfig } from './value-objects/harnesses-config.js';
+import type { FeatureNameValue } from './value-objects/feature-name.js';
+import type { FeatureName } from './value-objects/feature-name.js';
+import type { L1Config } from './value-objects/l1-config.js';
+import type { L2Config } from './value-objects/l2-config.js';
+import type { L3Config } from './value-objects/l3-config.js';
+import type { L4Config } from './value-objects/l4-config.js';
+
+export type LayerId = 'L1' | 'L2' | 'L3' | 'L4';
+export type PresetId = 'minimal' | 'standard' | 'strict';
+export type PlanningModeValue = 'interactive' | 'embedded-qa';
+type DeepPartial<T> = {
+  [K in keyof T]?: T[K] extends Array<infer TItem>
+    ? Array<DeepPartial<TItem>>
+    : T[K] extends object
+      ? DeepPartial<T[K]>
+      : T[K];
+};
+
+export interface HarnessConfigSourceDocument {
+  project: {
+    name: string;
+    preset: PresetId;
+  };
+  layers: DeepPartial<HarnessConfigResolvedDocument['layers']>;
+  quickMode: Partial<HarnessConfigResolvedDocument['quickMode']>;
+  phaseDependencies: HarnessConfigResolvedDocument['phaseDependencies'];
+  planningMode: HarnessConfigResolvedDocument['planningMode'];
+  harnesses: Partial<HarnessConfigResolvedDocument['harnesses']>;
+  paths: HarnessConfigResolvedDocument['paths'];
+  reporting: HarnessConfigResolvedDocument['reporting'];
+}
+
+export interface HarnessConfigResolvedDocument {
+  project: {
+    name: string;
+    preset: PresetId;
+  };
+  layers: {
+    L1: {
+      enabled: boolean;
+      rules: Record<string, string>;
+    };
+    L2: {
+      enabled: boolean;
+      validators: string[];
+    };
+    L3: {
+      enabled: boolean;
+      validators: string[];
+      coverageThreshold: number;
+    };
+    L4: {
+      enabled: boolean;
+      validators: string[];
+      schedule: string;
+    };
+  };
+  quickMode: {
+    allowedCategories: string[];
+    maintainedLayers: string[];
+    relaxedGates: string[];
+  };
+  phaseDependencies: {
+    preset: 'default' | 'custom';
+    override: boolean;
+    customRules: Array<{
+      phase: string;
+      requires: string[];
+    }>;
+  };
+  planningMode: {
+    default: PlanningModeValue;
+    perPhase: Record<string, PlanningModeValue>;
+  };
+  harnesses: {
+    agentLessonCollection: boolean;
+    cascadeUpdate: boolean;
+    bundleSizeLimit: number;
+    deadCodeGC: boolean;
+  };
+  paths: {
+    designDocs: string;
+    inceptionDocs: string;
+  };
+  reporting: {
+    format: string;
+    outputDir: string;
+  };
+}
+
+export type HarnessConfigV2 = HarnessConfigResolvedDocument;
+export type HarnessConfigV2Props = HarnessConfigResolvedDocument;
+
+export interface HarnessConfigReconstitutionProps {
+  sourceDocument: HarnessConfigSourceDocument;
+  resolvedDocument: HarnessConfigResolvedDocument;
+  pendingEvents?: readonly DomainEvent[];
+}
+
+export interface FeatureToggled {
+  type: 'FeatureToggled';
+  occurredAt: Date;
+  projectName: string;
+  featureName: FeatureNameValue | string;
+  previousState: boolean;
+  currentState: boolean;
+}
+
+export interface PresetApplied {
+  type: 'PresetApplied';
+  occurredAt: Date;
+  projectName: string;
+  preset: PresetId;
+  changedSections: readonly string[];
+}
+
+export type DomainEvent = FeatureToggled | PresetApplied;
+
+const SUPPORTED_FEATURE_NAMES = [
+  'agentLessonCollection',
+  'cascadeUpdate',
+  'bundleSizeLimit',
+  'deadCodeGC',
+] as const satisfies readonly FeatureNameValue[];
+
+export class UnknownLayerError extends ConfigFoundationDomainError {
+  constructor(layerId: string) {
+    super(`未知のレイヤーです: ${layerId} [L1-006]`, 'L1-006');
+    this.name = 'UnknownLayerError';
+  }
+}
+
+export class FeatureActivationRuleError extends ConfigFoundationDomainError {
+  constructor(message: string) {
+    super(`${message} [L1-005]`, 'L1-005');
+    this.name = 'FeatureActivationRuleError';
+  }
+}
+
+function deepClone<T>(value: T): T {
+  if (value instanceof Date) {
+    return new Date(value.getTime()) as T;
+  }
+
+  if (Array.isArray(value)) {
+    return value.map((item) => deepClone(item)) as T;
+  }
+
+  if (value !== null && typeof value === 'object') {
+    const clonedEntries = Object.entries(value).map(([key, entryValue]) => [
+      key,
+      deepClone(entryValue),
+    ]);
+
+    return Object.fromEntries(clonedEntries) as T;
+  }
+
+  return value;
+}
+
+function createFeatureToggledEvent(
+  projectName: string,
+  featureName: string,
+  previousState: boolean,
+  currentState: boolean,
+): FeatureToggled {
+  return Object.freeze({
+    type: 'FeatureToggled',
+    occurredAt: new Date(),
+    projectName,
+    featureName,
+    previousState,
+    currentState,
+  });
+}
+
+function assertSupportedFeature(name: FeatureName): FeatureNameValue {
+  const raw = name.toString();
+
+  if (!SUPPORTED_FEATURE_NAMES.includes(raw as FeatureNameValue)) {
+    throw new UnsupportedFeatureError(
+      `機能名 "${raw}" は利用できません。利用可能: ${SUPPORTED_FEATURE_NAMES.join(', ')}`,
+    );
+  }
+
+  return raw as FeatureNameValue;
+}
+
+function toHarnessesDocument(harnesses: HarnessesConfig): HarnessConfigResolvedDocument['harnesses'] {
+  return {
+    agentLessonCollection: harnesses.agentLessonCollection,
+    cascadeUpdate: harnesses.cascadeUpdate,
+    bundleSizeLimit: harnesses.bundleSizeLimit,
+    deadCodeGC: harnesses.deadCodeGC,
+  };
+}
+
+export class HarnessConfig {
+  readonly project: ProjectConfig;
+  readonly layers: LayersConfig;
+  readonly quickMode: QuickModeConfig;
+  readonly phaseDependencies: PhaseDependenciesConfig;
+  readonly planningMode: PlanningModeConfig;
+  readonly paths: PathsConfig;
+  readonly reporting: ReportingConfig;
+  harnesses: HarnessesConfig;
+
+  private sourceDocument: HarnessConfigSourceDocument;
+  private resolvedDocument: HarnessConfigResolvedDocument;
+  private pendingEvents: DomainEvent[];
+
+  private constructor(props: {
+    project: ProjectConfig;
+    layers: LayersConfig;
+    quickMode: QuickModeConfig;
+    phaseDependencies: PhaseDependenciesConfig;
+    planningMode: PlanningModeConfig;
+    harnesses: HarnessesConfig;
+    paths: PathsConfig;
+    reporting: ReportingConfig;
+    sourceDocument: HarnessConfigSourceDocument;
+    resolvedDocument: HarnessConfigResolvedDocument;
+    pendingEvents: readonly DomainEvent[];
+  }) {
+    this.project = props.project;
+    this.layers = props.layers;
+    this.quickMode = props.quickMode;
+    this.phaseDependencies = props.phaseDependencies;
+    this.planningMode = props.planningMode;
+    this.harnesses = props.harnesses;
+    this.paths = props.paths;
+    this.reporting = props.reporting;
+    this.sourceDocument = deepClone(props.sourceDocument);
+    this.resolvedDocument = deepClone(props.resolvedDocument);
+    this.pendingEvents = [...props.pendingEvents];
+  }
+
+  static reconstitute(props: HarnessConfigReconstitutionProps): HarnessConfig {
+    const project = ProjectConfig.create(props.resolvedDocument.project);
+    const layers = LayersConfig.create(props.resolvedDocument.layers);
+    const quickMode = QuickModeConfig.create(props.resolvedDocument.quickMode);
+    const phaseDependencies = PhaseDependenciesConfig.create(
+      props.resolvedDocument.phaseDependencies,
+    );
+    const planningMode = PlanningModeConfig.create(
+      props.resolvedDocument.planningMode,
+    );
+    const harnesses = HarnessesConfig.create(props.resolvedDocument.harnesses);
+    const paths = PathsConfig.create(props.resolvedDocument.paths);
+    const reporting = ReportingConfig.create(props.resolvedDocument.reporting);
+
+    if (
+      props.sourceDocument.project.preset !== props.resolvedDocument.project.preset
+    ) {
+      throw new ConfigValidationError(
+        'sourceDocument.project.preset と resolvedDocument.project.preset は一致しなければなりません',
+      );
+    }
+
+    return new HarnessConfig({
+      project,
+      layers,
+      quickMode,
+      phaseDependencies,
+      planningMode,
+      harnesses,
+      paths,
+      reporting,
+      sourceDocument: props.sourceDocument,
+      resolvedDocument: props.resolvedDocument,
+      pendingEvents: props.pendingEvents ?? [],
+    });
+  }
+
+  enableFeature(name: FeatureName): void {
+    const featureName = assertSupportedFeature(name);
+    const previousState = this.harnesses.isEnabled(name);
+    const nextHarnesses = this.harnesses.enable(name);
+
+    this.harnesses = nextHarnesses;
+    this.sourceDocument = {
+      ...this.sourceDocument,
+      harnesses: {
+        ...this.sourceDocument.harnesses,
+        [featureName]: toHarnessesDocument(nextHarnesses)[featureName],
+      },
+    };
+    this.resolvedDocument = {
+      ...this.resolvedDocument,
+      harnesses: toHarnessesDocument(nextHarnesses),
+    };
+    this.pendingEvents.push(
+      createFeatureToggledEvent(
+        this.project.name,
+        featureName,
+        previousState,
+        true,
+      ),
+    );
+  }
+
+  disableFeature(name: FeatureName): void {
+    const featureName = assertSupportedFeature(name);
+    const previousState = this.harnesses.isEnabled(name);
+    const nextHarnesses = this.harnesses.disable(name);
+
+    this.harnesses = nextHarnesses;
+    this.sourceDocument = {
+      ...this.sourceDocument,
+      harnesses: {
+        ...this.sourceDocument.harnesses,
+        [featureName]: toHarnessesDocument(nextHarnesses)[featureName],
+      },
+    };
+    this.resolvedDocument = {
+      ...this.resolvedDocument,
+      harnesses: toHarnessesDocument(nextHarnesses),
+    };
+    this.pendingEvents.push(
+      createFeatureToggledEvent(
+        this.project.name,
+        featureName,
+        previousState,
+        false,
+      ),
+    );
+  }
+
+  getLayerConfig(layerId: LayerId): L1Config | L2Config | L3Config | L4Config {
+    if (!['L1', 'L2', 'L3', 'L4'].includes(layerId)) {
+      throw new UnknownLayerError(layerId);
+    }
+
+    return this.layers.get(layerId);
+  }
+
+  isFeatureEnabled(name: FeatureName): boolean {
+    assertSupportedFeature(name);
+
+    return this.harnesses.isEnabled(name);
+  }
+
+  toResolvedConfig(): HarnessConfigV2 {
+    return deepClone(this.resolvedDocument);
+  }
+
+  toSourceDocument(): HarnessConfigSourceDocument {
+    return deepClone(this.sourceDocument);
+  }
+
+  pullDomainEvents(): readonly DomainEvent[] {
+    const events = [...this.pendingEvents];
+
+    this.pendingEvents = [];
+
+    return events;
+  }
+}

package/scripts/harness/config-foundation/domain/ports/config-repository-port.ts

@@ -0,0 +1,8 @@
+/**
+ * @layer domain
+ * @unit config-foundation
+ */
+export interface ConfigRepositoryPort {
+  load(configPath?: string): Promise<{ path: string; document: unknown }>;
+  save(configPath: string, document: unknown): Promise<void>;
+}

package/scripts/harness/config-foundation/domain/ports/config-schema-validator-port.ts

@@ -0,0 +1,9 @@
+/**
+ * @layer domain
+ * @unit config-foundation
+ */
+import type { HarnessError } from '../../../harness-error/domain/value-objects/harness-error.js';
+
+export interface ConfigSchemaValidatorPort {
+  validate(document: unknown): readonly HarnessError[];
+}

package/scripts/harness/config-foundation/domain/ports/feature-registry-port.ts

@@ -0,0 +1,7 @@
+/**
+ * @layer domain
+ * @unit config-foundation
+ */
+export interface FeatureRegistryPort {
+  listAvailable(): readonly string[];
+}

package/scripts/harness/config-foundation/domain/services/feature-registry.ts

@@ -0,0 +1,42 @@
+/**
+ * @layer domain
+ * @unit config-foundation
+ */
+import { UnsupportedFeatureError } from '../errors/unsupported-feature-error.js';
+import type { FeatureRegistryPort } from '../ports/feature-registry-port.js';
+import { FeatureName, type FeatureNameValue } from '../value-objects/feature-name.js';
+
+const FEATURE_ORDER: readonly FeatureNameValue[] = [
+  'agentLessonCollection',
+  'cascadeUpdate',
+  'bundleSizeLimit',
+  'deadCodeGC',
+];
+
+export class FeatureRegistry {
+  listAvailable(source: FeatureRegistryPort): readonly FeatureName[] {
+    const uniqueNames = [...new Set(source.listAvailable())];
+
+    return uniqueNames
+      .map((name) => FeatureName.create(name, FEATURE_ORDER))
+      .sort(
+        (left, right) =>
+          FEATURE_ORDER.indexOf(left.value) - FEATURE_ORDER.indexOf(right.value),
+      );
+  }
+
+  ensureAvailable(name: string, source: FeatureRegistryPort): FeatureName {
+    const available = this.listAvailable(source);
+    const actual = available.find((featureName) => featureName.toString() === name);
+
+    if (!actual) {
+      throw new UnsupportedFeatureError(
+        `機能名 "${name}" は利用できません。利用可能: ${available
+          .map((featureName) => featureName.toString())
+          .join(', ')}`,
+      );
+    }
+
+    return actual;
+  }
+}

package/scripts/harness/config-foundation/domain/services/preset-resolution-service.ts

@@ -0,0 +1,197 @@
+/**
+ * @layer domain
+ * @unit config-foundation
+ */
+import { ConfigFoundationDomainError } from '../errors/config-foundation-domain-error.js';
+import type {
+  HarnessConfigResolvedDocument,
+  HarnessConfigSourceDocument,
+} from '../harness-config.js';
+import { HarnessesConfig } from '../value-objects/harnesses-config.js';
+import type { FeatureToggle } from '../value-objects/feature-toggle.js';
+
+export interface PresetDefinition {
+  layers: HarnessConfigResolvedDocument['layers'];
+  quickMode: HarnessConfigResolvedDocument['quickMode'];
+  phaseDependencies: HarnessConfigResolvedDocument['phaseDependencies'];
+  planningMode: HarnessConfigResolvedDocument['planningMode'];
+  harnesses: HarnessConfigResolvedDocument['harnesses'];
+  paths: HarnessConfigResolvedDocument['paths'];
+  reporting: HarnessConfigResolvedDocument['reporting'];
+}
+
+export class InvalidPresetDefinitionError extends ConfigFoundationDomainError {
+  constructor(message: string) {
+    super(`${message} [L1-007]`, 'L1-007');
+    this.name = 'InvalidPresetDefinitionError';
+  }
+}
+
+export class ConfigMergeError extends ConfigFoundationDomainError {
+  constructor(message: string) {
+    super(`${message} [L1-008]`, 'L1-008');
+    this.name = 'ConfigMergeError';
+  }
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function deepClone<T>(value: T): T {
+  if (Array.isArray(value)) {
+    return value.map((item) => deepClone(item)) as T;
+  }
+
+  if (isPlainObject(value)) {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, entryValue]) => [key, deepClone(entryValue)]),
+    ) as T;
+  }
+
+  return value;
+}
+
+function deepMerge<T>(baseValue: T, overrideValue: unknown, path: string): T {
+  if (overrideValue === undefined) {
+    return deepClone(baseValue);
+  }
+
+  if (Array.isArray(baseValue)) {
+    if (!Array.isArray(overrideValue)) {
+      throw new ConfigMergeError(`${path} の配列を別型で上書きできません`);
+    }
+
+    return deepClone(overrideValue) as T;
+  }
+
+  if (isPlainObject(baseValue)) {
+    if (!isPlainObject(overrideValue)) {
+      throw new ConfigMergeError(`${path} のobjectを別型で上書きできません`);
+    }
+
+    const merged: Record<string, unknown> = {};
+    const keys = new Set([
+      ...Object.keys(baseValue),
+      ...Object.keys(overrideValue),
+    ]);
+
+    for (const key of keys) {
+      const nestedBaseValue = (baseValue as Record<string, unknown>)[key];
+      const nestedOverrideValue = overrideValue[key];
+
+      if (nestedBaseValue === undefined) {
+        merged[key] = deepClone(nestedOverrideValue);
+        continue;
+      }
+
+      merged[key] = deepMerge(
+        nestedBaseValue,
+        nestedOverrideValue,
+        `${path}.${key}`,
+      );
+    }
+
+    return merged as T;
+  }
+
+  if (Array.isArray(overrideValue) || isPlainObject(overrideValue)) {
+    throw new ConfigMergeError(`${path} のprimitiveを別構造で上書きできません`);
+  }
+
+  return deepClone(overrideValue as T);
+}
+
+function assertValidPresetDefinition(
+  presetDefinition: PresetDefinition,
+): void {
+  const requiredKeys: Array<keyof PresetDefinition> = [
+    'layers',
+    'quickMode',
+    'phaseDependencies',
+    'planningMode',
+    'harnesses',
+    'paths',
+    'reporting',
+  ];
+
+  for (const key of requiredKeys) {
+    if (
+      !(key in presetDefinition) ||
+      (presetDefinition as unknown as Record<string, unknown>)[key] === undefined
+    ) {
+      throw new InvalidPresetDefinitionError(
+        `presetDefinition.${key} は必須です`,
+      );
+    }
+  }
+}
+
+function toHarnessesDocument(
+  harnesses: HarnessesConfig,
+): HarnessConfigResolvedDocument['harnesses'] {
+  return {
+    agentLessonCollection: harnesses.agentLessonCollection,
+    cascadeUpdate: harnesses.cascadeUpdate,
+    bundleSizeLimit: harnesses.bundleSizeLimit,
+    deadCodeGC: harnesses.deadCodeGC,
+  };
+}
+
+export class PresetResolutionService {
+  resolve(
+    sourceDocument: HarnessConfigSourceDocument,
+    presetDefinition: PresetDefinition,
+  ): HarnessConfigResolvedDocument {
+    assertValidPresetDefinition(presetDefinition);
+
+    return {
+      project: {
+        name: sourceDocument.project.name,
+        preset: sourceDocument.project.preset,
+      },
+      layers: deepMerge(presetDefinition.layers, sourceDocument.layers, 'layers'),
+      quickMode: deepMerge(
+        presetDefinition.quickMode,
+        sourceDocument.quickMode,
+        'quickMode',
+      ),
+      phaseDependencies: deepMerge(
+        presetDefinition.phaseDependencies,
+        sourceDocument.phaseDependencies,
+        'phaseDependencies',
+      ),
+      planningMode: deepMerge(
+        presetDefinition.planningMode,
+        sourceDocument.planningMode,
+        'planningMode',
+      ),
+      harnesses: deepMerge(
+        presetDefinition.harnesses,
+        sourceDocument.harnesses,
+        'harnesses',
+      ),
+      paths: deepMerge(presetDefinition.paths, sourceDocument.paths, 'paths'),
+      reporting: deepMerge(
+        presetDefinition.reporting,
+        sourceDocument.reporting,
+        'reporting',
+      ),
+    };
+  }
+
+  applyFeatureOverride(
+    document: HarnessConfigResolvedDocument,
+    override: FeatureToggle,
+  ): HarnessConfigResolvedDocument {
+    const harnesses = HarnessesConfig.create(document.harnesses);
+    const nextHarnesses = override.enabled
+      ? harnesses.enable(override.name)
+      : harnesses.disable(override.name);
+
+    return {
+      ...deepClone(document),
+      harnesses: toHarnessesDocument(nextHarnesses),
+    };
+  }
+}

package/scripts/harness/config-foundation/domain/value-objects/custom-phase-rule.ts

@@ -0,0 +1,42 @@
+/**
+ * @layer domain
+ * @unit config-foundation
+ *
+ * カスタムフェーズルールを表す値オブジェクト
+ * phase は空文字不可、requires は重複不可
+ */
+import { ConfigValidationError } from '../errors/config-validation-error.js';
+
+export interface CustomPhaseRuleProps {
+  readonly phase: string;
+  readonly requires: readonly string[];
+}
+
+export class CustomPhaseRule {
+  readonly phase: string;
+  readonly requires: readonly string[];
+
+  constructor(props: CustomPhaseRuleProps) {
+    if (props.phase === '') {
+      throw new ConfigValidationError('phase は空文字にできません');
+    }
+
+    const uniqueRequires = new Set(props.requires);
+    if (uniqueRequires.size !== props.requires.length) {
+      throw new ConfigValidationError('requires に重複する要素があります');
+    }
+
+    this.phase = props.phase;
+    this.requires = [...props.requires];
+  }
+
+  static create(raw: CustomPhaseRuleProps): CustomPhaseRule {
+    return new CustomPhaseRule(raw);
+  }
+
+  equals(other: CustomPhaseRule): boolean {
+    if (this.phase !== other.phase) return false;
+    if (this.requires.length !== other.requires.length) return false;
+    return this.requires.every((val, idx) => val === other.requires[idx]);
+  }
+}