phasegate 0.16.0 → 0.31.0

package/scripts/harness/phase-dependency-model/domain/definitions/{default-phase-nodes.ts → full-phase-nodes.ts}

@@ -22,7 +22,7 @@ const createNode = (
     artifacts: artifacts.map((artifact) => Artifact.create(artifact)),
   });
 
-export const DEFAULT_PHASE_NODES: readonly PhaseNode[] = Object.freeze([
+export const FULL_PHASE_NODES: readonly PhaseNode[] = Object.freeze([
   createNode(1, 'product-architect', [
     {
       name: 'product-overview-plan',

package/scripts/harness/phase-dependency-model/domain/definitions/full-story-reflection-defaults.ts

@@ -0,0 +1,28 @@
+/**
+ * @layer domain
+ * @unit phase-dependency-model
+ */
+
+import { StoryReflectionConfig } from '../values/story-reflection-config.js';
+import { StoryReflectionMapping } from '../values/story-reflection-mapping.js';
+
+export const FULL_STORY_REFLECTION_DEFAULTS: StoryReflectionConfig = StoryReflectionConfig.create({
+  enabled: true,
+  mappings: [
+    StoryReflectionMapping.create({
+      inception: 'docs/inception/{unit}/{storyId}/logical_design.md',
+      product: 'docs/product/construction/{unit}/logical_design.md',
+      required: true,
+    }),
+    StoryReflectionMapping.create({
+      inception: 'docs/inception/{unit}/{storyId}/domain_model.md',
+      product: 'docs/product/construction/{unit}/domain_model.md',
+      required: true,
+    }),
+    StoryReflectionMapping.create({
+      inception: 'docs/inception/{unit}/{storyId}/uiux_design.md',
+      product: 'docs/product/construction/{unit}/uiux_design.md',
+      required: false,
+    }),
+  ],
+});

package/scripts/harness/phase-dependency-model/domain/definitions/minimal-phase-dependencies.ts

@@ -0,0 +1,32 @@
+/**
+ * @layer domain
+ * @unit phase-dependency-model
+ */
+
+import { MINIMAL_PHASE_NODES } from './minimal-phase-nodes.js';
+import { PhaseDependency } from '../values/phase-dependency.js';
+import { PhaseNode } from '../values/phase-node.js';
+
+const nodeIndex = new Map<string, PhaseNode>(
+  MINIMAL_PHASE_NODES.map((node) => [node.nodeKey(), node]),
+);
+
+const getNode = (nodeKey: string): PhaseNode => {
+  const actual = nodeIndex.get(nodeKey);
+
+  if (!actual) {
+    throw new Error(`ノードが見つかりません: ${nodeKey}`);
+  }
+
+  return actual;
+};
+
+const createDependency = (
+  from: string,
+  to: string,
+  type: 'requires' | 'recommends' = 'requires',
+): PhaseDependency => PhaseDependency.create({ from: getNode(from), to: getNode(to), type });
+
+export const MINIMAL_PHASE_DEPENDENCIES: readonly PhaseDependency[] = Object.freeze([
+  createDependency('1:product-architect', '2:logical-designer'),
+]);

package/scripts/harness/phase-dependency-model/domain/definitions/minimal-phase-nodes.ts

@@ -0,0 +1,50 @@
+/**
+ * @layer domain
+ * @unit phase-dependency-model
+ */
+
+import { Artifact } from '../values/artifact.js';
+import { PhaseLevel } from '../values/phase-level.js';
+import { PhaseNode } from '../values/phase-node.js';
+
+const createNode = (
+  level: 1 | 2 | 3,
+  skillName: string,
+  artifacts: readonly {
+    readonly name: string;
+    readonly path: string;
+    readonly required: boolean;
+  }[],
+): PhaseNode =>
+  PhaseNode.create({
+    skillName,
+    level: PhaseLevel.create(level),
+    artifacts: artifacts.map((artifact) => Artifact.create(artifact)),
+  });
+
+export const MINIMAL_PHASE_NODES: readonly PhaseNode[] = Object.freeze([
+  createNode(1, 'product-architect', [
+    {
+      name: 'product-overview-plan',
+      path: 'docs/inception/_shared/product_overview_plan.md',
+      required: true,
+    },
+    {
+      name: 'product-overview',
+      path: 'docs/product/product_overview.md',
+      required: true,
+    },
+  ]),
+  createNode(2, 'logical-designer', [
+    {
+      name: 'logical-design-plan',
+      path: 'docs/inception/{unit}/logical_design_plan.md',
+      required: true,
+    },
+    {
+      name: 'logical-design',
+      path: 'docs/product/construction/{unit}/logical_design.md',
+      required: true,
+    },
+  ]),
+]);

package/scripts/harness/phase-dependency-model/domain/definitions/minimal-story-reflection-defaults.ts

@@ -0,0 +1,8 @@
+/**
+ * @layer domain
+ * @unit phase-dependency-model
+ */
+
+import { StoryReflectionConfig } from '../values/story-reflection-config.js';
+
+export const MINIMAL_STORY_REFLECTION_DEFAULTS: StoryReflectionConfig = StoryReflectionConfig.disabled();

package/scripts/harness/phase-dependency-model/domain/definitions/standard-phase-dependencies.ts

@@ -0,0 +1,39 @@
+/**
+ * @layer domain
+ * @unit phase-dependency-model
+ */
+
+import { STANDARD_PHASE_NODES } from './standard-phase-nodes.js';
+import { PhaseDependency } from '../values/phase-dependency.js';
+import { PhaseNode } from '../values/phase-node.js';
+
+const nodeIndex = new Map<string, PhaseNode>(
+  STANDARD_PHASE_NODES.map((node) => [node.nodeKey(), node]),
+);
+
+const getNode = (nodeKey: string): PhaseNode => {
+  const actual = nodeIndex.get(nodeKey);
+
+  if (!actual) {
+    throw new Error(`ノードが見つかりません: ${nodeKey}`);
+  }
+
+  return actual;
+};
+
+const createDependency = (
+  from: string,
+  to: string,
+  type: 'requires' | 'recommends' = 'requires',
+): PhaseDependency => PhaseDependency.create({ from: getNode(from), to: getNode(to), type });
+
+export const STANDARD_PHASE_DEPENDENCIES: readonly PhaseDependency[] = Object.freeze([
+  createDependency('1:product-architect', '1:story-writer'),
+  createDependency('1:story-writer', '2:domain-designer'),
+  createDependency('2:domain-designer', '2:logical-designer'),
+  createDependency('2:logical-designer', '3:logical-designer'),
+  createDependency('3:logical-designer', '3:scenario-test-designer'),
+  createDependency('3:scenario-test-designer', '3:scenario-test-logic-designer'),
+  createDependency('3:scenario-test-logic-designer', '3:implementation-readiness-checker'),
+  createDependency('3:implementation-readiness-checker', '3:story-implementor'),
+]);

package/scripts/harness/phase-dependency-model/domain/definitions/standard-phase-nodes.ts

@@ -0,0 +1,118 @@
+/**
+ * @layer domain
+ * @unit phase-dependency-model
+ */
+
+import { Artifact } from '../values/artifact.js';
+import { PhaseLevel } from '../values/phase-level.js';
+import { PhaseNode } from '../values/phase-node.js';
+
+const createNode = (
+  level: 1 | 2 | 3,
+  skillName: string,
+  artifacts: readonly {
+    readonly name: string;
+    readonly path: string;
+    readonly required: boolean;
+  }[],
+): PhaseNode =>
+  PhaseNode.create({
+    skillName,
+    level: PhaseLevel.create(level),
+    artifacts: artifacts.map((artifact) => Artifact.create(artifact)),
+  });
+
+export const STANDARD_PHASE_NODES: readonly PhaseNode[] = Object.freeze([
+  createNode(1, 'product-architect', [
+    {
+      name: 'product-overview-plan',
+      path: 'docs/inception/_shared/product_overview_plan.md',
+      required: true,
+    },
+    {
+      name: 'product-overview',
+      path: 'docs/product/product_overview.md',
+      required: true,
+    },
+  ]),
+  createNode(1, 'story-writer', [
+    {
+      name: 'story-writer-plan',
+      path: 'docs/inception/_shared/story_writer_plan.md',
+      required: true,
+    },
+    {
+      name: 'user-stories',
+      path: 'docs/product/user_stories.md',
+      required: true,
+    },
+  ]),
+  createNode(2, 'domain-designer', [
+    {
+      name: 'domain-model-plan',
+      path: 'docs/inception/{unit}/domain_model_plan.md',
+      required: true,
+    },
+    {
+      name: 'domain-model',
+      path: 'docs/product/construction/{unit}/domain_model.md',
+      required: true,
+    },
+  ]),
+  createNode(2, 'logical-designer', [
+    {
+      name: 'logical-design-plan',
+      path: 'docs/inception/{unit}/logical_design_plan.md',
+      required: true,
+    },
+    {
+      name: 'logical-design',
+      path: 'docs/product/construction/{unit}/logical_design.md',
+      required: true,
+    },
+  ]),
+  createNode(3, 'logical-designer', [
+    {
+      name: 'story-logical-design-plan',
+      path: 'docs/inception/{unit}/{storyId}/logical_design_plan.md',
+      required: false,
+    },
+    {
+      name: 'story-logical-design',
+      path: 'docs/inception/{unit}/{storyId}/logical_design.md',
+      required: false,
+    },
+  ]),
+  createNode(3, 'scenario-test-designer', [
+    {
+      name: 'scenario-test-plan',
+      path: 'docs/inception/{unit}/{storyId}/scenario_test_plan.md',
+      required: false,
+    },
+    {
+      name: 'scenario-test-design',
+      path: 'docs/inception/{unit}/{storyId}/scenario_test_design.md',
+      required: false,
+    },
+  ]),
+  createNode(3, 'scenario-test-logic-designer', [
+    {
+      name: 'scenario-test-logic-plan',
+      path: 'docs/inception/{unit}/{storyId}/scenario_test_logic_plan.md',
+      required: false,
+    },
+    {
+      name: 'scenario-test-logic',
+      path: 'docs/inception/{unit}/{storyId}/scenario_test_logic.md',
+      required: false,
+    },
+  ]),
+  createNode(3, 'implementation-readiness-checker', []),
+  createNode(3, 'story-implementor', [
+    {
+      name: 'tdd-implementation-plan',
+      path: 'docs/inception/{unit}/{storyId}/tdd_implementation_plan.md',
+      required: false,
+    },
+  ]),
+]);

package/scripts/harness/phase-dependency-model/domain/definitions/standard-story-reflection-defaults.ts

@@ -0,0 +1,23 @@
+/**
+ * @layer domain
+ * @unit phase-dependency-model
+ */
+
+import { StoryReflectionConfig } from '../values/story-reflection-config.js';
+import { StoryReflectionMapping } from '../values/story-reflection-mapping.js';
+
+export const STANDARD_STORY_REFLECTION_DEFAULTS: StoryReflectionConfig = StoryReflectionConfig.create({
+  enabled: true,
+  mappings: [
+    StoryReflectionMapping.create({
+      inception: 'docs/inception/{unit}/{storyId}/logical_design.md',
+      product: 'docs/product/construction/{unit}/logical_design.md',
+      required: true,
+    }),
+    StoryReflectionMapping.create({
+      inception: 'docs/inception/{unit}/{storyId}/domain_model.md',
+      product: 'docs/product/construction/{unit}/domain_model.md',
+      required: false,
+    }),
+  ],
+});

package/scripts/harness/phase-dependency-model/domain/models/phase-structure.ts

@@ -3,9 +3,16 @@
  * @unit phase-dependency-model
  */
 
-import { DEFAULT_PHASE_DEPENDENCIES } from '../definitions/default-phase-dependencies.js';
-import { DEFAULT_PHASE_NODES } from '../definitions/default-phase-nodes.js';
+import { FULL_PHASE_DEPENDENCIES } from '../definitions/full-phase-dependencies.js';
+import { FULL_PHASE_NODES } from '../definitions/full-phase-nodes.js';
+import { MINIMAL_PHASE_DEPENDENCIES } from '../definitions/minimal-phase-dependencies.js';
+import { MINIMAL_PHASE_NODES } from '../definitions/minimal-phase-nodes.js';
+import { STANDARD_PHASE_DEPENDENCIES } from '../definitions/standard-phase-dependencies.js';
+import { STANDARD_PHASE_NODES } from '../definitions/standard-phase-nodes.js';
+import { GateGraph } from '../services/gate-graph.js';
+import { Artifact } from '../values/artifact.js';
 import { CustomRule, InvalidCustomRuleError } from '../values/custom-rule.js';
+import { GateDefinition } from '../values/gate-definition.js';
 import { PhaseCustomizationPolicy } from '../values/phase-customization-policy.js';
 import { PhaseDependency } from '../values/phase-dependency.js';
 import { PhaseGateResult } from '../values/phase-gate-result.js';
@@ -115,6 +122,34 @@ const createAuditPayload = (
   });
 };
 
+const resolvePresetDefinitions = (preset: string): {
+  nodes: readonly PhaseNode[];
+  dependencies: readonly PhaseDependency[];
+} => {
+  switch (preset) {
+    case 'standard':
+      return { nodes: STANDARD_PHASE_NODES, dependencies: STANDARD_PHASE_DEPENDENCIES };
+    case 'minimal':
+      return { nodes: MINIMAL_PHASE_NODES, dependencies: MINIMAL_PHASE_DEPENDENCIES };
+    case 'full':
+    case 'custom':
+    default:
+      return { nodes: FULL_PHASE_NODES, dependencies: FULL_PHASE_DEPENDENCIES };
+  }
+};
+
+const buildNonRelaxableDependencies = (
+  dependencies: readonly PhaseDependency[],
+): readonly PhaseDependency[] =>
+  Object.freeze(
+    dependencies.filter(
+      (dependency) =>
+        dependency.isLevelTransition() ||
+        dependency.to.nodeKey() === '3:implementation-readiness-checker' ||
+        dependency.to.nodeKey() === '3:story-implementor',
+    ),
+  );
+
 export class PhaseStructure {
   readonly levels: ReadonlyMap<1 | 2 | 3, readonly PhaseNode[]>;
   readonly nodeIndex: ReadonlyMap<string, PhaseNode>;
@@ -140,30 +175,43 @@ export class PhaseStructure {
   }
 
   static createDefault(policy: PhaseCustomizationPolicy): PhaseStructure {
-    const levels = buildLevels(DEFAULT_PHASE_NODES);
-    const nodeIndex = buildNodeIndex(DEFAULT_PHASE_NODES);
-    const nonRelaxableDependencies = Object.freeze(
-      DEFAULT_PHASE_DEPENDENCIES.filter(
-        (dependency) =>
-          dependency.isLevelTransition() ||
-          dependency.to.nodeKey() === '3:implementation-readiness-checker' ||
-          dependency.to.nodeKey() === '3:story-implementor',
+    const { nodes, dependencies } = resolvePresetDefinitions(policy.preset);
+
+    return PhaseStructure.createFromNodesAndDependencies(nodes, dependencies, policy);
+  }
+
+  static fromGates(gates: GateDefinition[], policy: PhaseCustomizationPolicy): PhaseStructure {
+    GateGraph.build(gates);
+
+    const nodes = gates.map((gate) =>
+      PhaseNode.create({
+        skillName: gate.name.value,
+        level: gate.level,
+        artifacts: gate.requires.map((requirement, index) =>
+          Artifact.create({
+            name: `${gate.name.value}-${index + 1}`,
+            path: requirement.path,
+            required: requirement.required,
+          }),
+        ),
+      }),
+    );
+    const nodeByGateName = new Map<string, PhaseNode>(
+      gates.map((gate, index) => [gate.name.value, nodes[index]]),
+    );
+    const dependencies = Object.freeze(
+      gates.flatMap((gate) =>
+        gate.dependsOn.map((dependencyName) =>
+          PhaseDependency.create({
+            from: nodeByGateName.get(dependencyName.value) as PhaseNode,
+            to: nodeByGateName.get(gate.name.value) as PhaseNode,
+            type: 'requires',
+          }),
+        ),
       ),
     );
-    const base = new PhaseStructure({
-      levels,
-      nodeIndex,
-      defaultDependencies: DEFAULT_PHASE_DEPENDENCIES,
-      effectiveDependencies: DEFAULT_PHASE_DEPENDENCIES,
-      customizationPolicy: policy,
-      nonRelaxableDependencies,
-    });
 
-    if (!policy.hasRules()) {
-      return base;
-    }
-
-    return base.applyCustomization(policy);
+    return PhaseStructure.createFromNodesAndDependencies(nodes, dependencies, policy);
   }
 
   checkPhaseGate(
@@ -486,4 +534,28 @@ export class PhaseStructure {
       visit(nodeKey);
     }
   }
+
+  private static createFromNodesAndDependencies(
+    nodes: readonly PhaseNode[],
+    dependencies: readonly PhaseDependency[],
+    policy: PhaseCustomizationPolicy,
+  ): PhaseStructure {
+    const levels = buildLevels(nodes);
+    const nodeIndex = buildNodeIndex(nodes);
+    const nonRelaxableDependencies = buildNonRelaxableDependencies(dependencies);
+    const base = new PhaseStructure({
+      levels,
+      nodeIndex,
+      defaultDependencies: dependencies,
+      effectiveDependencies: dependencies,
+      customizationPolicy: policy,
+      nonRelaxableDependencies,
+    });
+
+    if (!policy.hasRules()) {
+      return base;
+    }
+
+    return base.applyCustomization(policy);
+  }
 }

package/scripts/harness/phase-dependency-model/domain/ports/glob-matcher-port.ts

@@ -0,0 +1,8 @@
+/**
+ * @layer domain
+ * @unit phase-dependency-model
+ */
+
+export interface GlobMatcherPort {
+  match(pattern: string, path: string): boolean;
+}

package/scripts/harness/phase-dependency-model/domain/ports/phase-config-provider-port.ts

@@ -5,9 +5,11 @@
 
 import type { PhaseCustomizationPolicy } from '../values/phase-customization-policy.js';
 import type { PlanningMode } from '../values/planning-mode.js';
+import type { StoryReflectionConfig } from '../values/story-reflection-config.js';
 
 export interface PhaseConfigProviderPort {
   getPlanningMode(scope: { unitId?: string; storyId?: string }): Promise<PlanningMode>;
   getCustomizationPolicy(): Promise<PhaseCustomizationPolicy>;
   getReportingOutputDir(): Promise<string>;
+  getStoryReflectionConfig(): Promise<StoryReflectionConfig>;
 }

package/scripts/harness/phase-dependency-model/domain/ports/story-annotation-verifier-port.ts

@@ -0,0 +1,14 @@
+// @unit phase-dependency-model
+// @layer domain
+
+export interface StoryAnnotationVerificationResult {
+  readonly hasAnnotation: boolean;
+  readonly storyId?: string;
+}
+
+export interface StoryAnnotationVerifierPort {
+  verify(
+    targetFilePath: string,
+    tag: string,
+  ): Promise<StoryAnnotationVerificationResult>;
+}

package/scripts/harness/phase-dependency-model/domain/ports/story-reflection-file-system-port.ts

@@ -0,0 +1,16 @@
+/**
+ * @layer domain
+ * @unit phase-dependency-model
+ */
+
+export interface StoryReflectionFileSystemPort {
+  /** inception/{unit}/ 配下の storyId ディレクトリ名一覧を返す */
+  listStoryDirectories(unitId: string): Promise<readonly string[]>;
+  /** ファイルの存在チェック */
+  fileExists(path: string): Promise<boolean>;
+  /** product 文書内に @story-id {storyId} アノテーションが含まれているか */
+  fileContainsStoryAnnotation(
+    productPath: string,
+    storyId: string,
+  ): Promise<boolean>;
+}