phasegate 0.91.0 → 0.107.0

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

@@ -3,10 +3,8 @@
 
 export interface StoryReflectionFileSystemPort {
   listStoryDirectories(unitId: string): Promise<readonly string[]>;
+  storyAffectsUnit(storyId: string, unitId: string): Promise<boolean>;
   fileExists(path: string): Promise<boolean>;
   /** product 文書内に @story-id {storyId} アノテーションが含まれているか */
-  fileContainsStoryAnnotation(
-    productPath: string,
-    storyId: string,
-  ): Promise<boolean>;
+  fileContainsStoryAnnotation(productPath: string, storyId: string): Promise<boolean>;
 }

package/scripts/harness/phase-dependency-model/domain/services/story-reflection-checker.ts

@@ -3,20 +3,22 @@
  * @unit phase-dependency-model
  */
 
-import type { StoryReflectionConfig } from '../values/story-reflection-config.js';
-import type { StoryReflectionFileSystemPort } from '../ports/story-reflection-file-system-port.js';
-import {
-  StoryReflectionResult,
-  type StoryReflectionViolation,
-} from '../values/story-reflection-result.js';
+import type { StoryReflectionFileSystemPort } from "../ports/story-reflection-file-system-port.js";
+import type { StoryReflectionConfig } from "../values/story-reflection-config.js";
+import type { StoryReflectionMapping } from "../values/story-reflection-mapping.js";
+import { StoryReflectionResult, type StoryReflectionViolation } from "../values/story-reflection-result.js";
+
+const CROSS_WORK_ITEM_PATTERN = /^WI-\d+$/;
+
+interface ResolvedInceptionPath {
+  readonly path: string;
+  readonly isCrossWorkItem: boolean;
+}
 
 export class StoryReflectionChecker {
   constructor(private readonly fsPort: StoryReflectionFileSystemPort) {}
 
-  async check(
-    unitId: string,
-    config: StoryReflectionConfig,
-  ): Promise<StoryReflectionResult> {
+  async check(unitId: string, config: StoryReflectionConfig): Promise<StoryReflectionResult> {
     if (!config.enabled) {
       return StoryReflectionResult.pass();
     }
@@ -32,23 +34,28 @@ export class StoryReflectionChecker {
 
     for (const storyId of storyIds) {
       for (const mapping of config.mappings) {
-        const { inception: inceptionPath, product: productPath } =
-          mapping.resolve({ unitId, storyId });
+        const { product: productPath } = mapping.resolve({ unitId, storyId });
+        const resolvedInception = await this.resolveInceptionPath({
+          mapping,
+          unitId,
+          storyId,
+        });
 
-        const inceptionExists = await this.fsPort.fileExists(inceptionPath);
+        if (resolvedInception === null) {
+          continue;
+        }
 
-        if (!inceptionExists) {
+        if (resolvedInception.isCrossWorkItem && !(await this.fsPort.storyAffectsUnit(storyId, unitId))) {
           continue;
         }
 
-        const hasAnnotation =
-          await this.fsPort.fileContainsStoryAnnotation(productPath, storyId);
+        const hasAnnotation = await this.fsPort.fileContainsStoryAnnotation(productPath, storyId);
 
         if (!hasAnnotation) {
           const violation: StoryReflectionViolation = {
             storyId,
             mapping,
-            inceptionPath,
+            inceptionPath: resolvedInception.path,
             productPath,
           };
 
@@ -63,4 +70,34 @@ export class StoryReflectionChecker {
 
     return StoryReflectionResult.create({ violations, warnings });
   }
+
+  private async resolveInceptionPath(input: {
+    readonly mapping: StoryReflectionMapping;
+    readonly unitId: string;
+    readonly storyId: string;
+  }): Promise<ResolvedInceptionPath | null> {
+    const normalPath = input.mapping.resolve({
+      unitId: input.unitId,
+      storyId: input.storyId,
+    }).inception;
+
+    if (await this.fsPort.fileExists(normalPath)) {
+      return { path: normalPath, isCrossWorkItem: false };
+    }
+
+    if (!CROSS_WORK_ITEM_PATTERN.test(input.storyId)) {
+      return null;
+    }
+
+    const crossPath = input.mapping.resolve({
+      unitId: "_cross",
+      storyId: input.storyId,
+    }).inception;
+
+    if (await this.fsPort.fileExists(crossPath)) {
+      return { path: crossPath, isCrossWorkItem: true };
+    }
+
+    return null;
+  }
 }

package/scripts/harness/phase-dependency-model/infrastructure/filesystem/file-system-story-reflection-adapter.ts

@@ -3,9 +3,15 @@
  * @unit phase-dependency-model
  */
 
-import { readdir, readFile, access } from 'node:fs/promises';
-import path from 'node:path';
-import type { StoryReflectionFileSystemPort } from '../../domain/ports/story-reflection-file-system-port.js';
+import type { Dirent } from "node:fs";
+import { access, readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import type { StoryReflectionFileSystemPort } from "../../domain/ports/story-reflection-file-system-port.js";
+
+const CROSS_WORK_ITEM_PATTERN = /^WI-\d+$/;
+const FRONTMATTER_PATTERN = /^---\r?\n([\s\S]*?)\r?\n---/;
+const AFFECTS_INLINE_PATTERN = /^affects:\s*\[([^\]]*)\]\s*$/m;
+const LEGACY_ID_PATTERN = /^legacy_id:\s*([A-Z][\w]+-\d+)\s*$/m;
 
 export interface FileSystemStoryReflectionAdapterDeps {
   readonly rootDir: string;
@@ -15,39 +21,67 @@ export interface FileSystemStoryReflectionAdapterDeps {
 
 /**
  * ファイルシステム上の docs/inception ディレクトリ列挙と
- * product 文書内 `@story-id` アノテーション検索を実装するアダプタ。
+ * product 文書内 `@story-id` / `@issue-id` / `@work-item-id` アノテーション
+ * 検索を実装するアダプタ。
  *
  * 存在しないパス・読めないファイルは true/false に正規化し例外を投げない
  * ことで、上位 (StoryReflectionChecker) の純粋性を保つ。
+ *
+ * ISSUE-026 / H02-04: `@issue-id` / `@work-item-id` も `@story-id` と同等に
+ * 認識する（WI 一本化への段階移行のため、既存 `@story-id` と併存）。
  */
-export class FileSystemStoryReflectionAdapter
-  implements StoryReflectionFileSystemPort
-{
+export class FileSystemStoryReflectionAdapter implements StoryReflectionFileSystemPort {
   private readonly rootDir: string;
   private readonly inceptionRoot: string;
 
   constructor(deps: FileSystemStoryReflectionAdapterDeps) {
     this.rootDir = deps.rootDir;
-    this.inceptionRoot = deps.inceptionRoot ?? 'docs/inception';
+    this.inceptionRoot = deps.inceptionRoot ?? "docs/inception";
   }
 
   async listStoryDirectories(unitId: string): Promise<readonly string[]> {
-    const unitDir = path.join(this.rootDir, this.inceptionRoot, unitId);
+    const ids = new Set<string>();
 
-    let entries;
-    try {
-      entries = await readdir(unitDir, { withFileTypes: true });
-    } catch {
-      return [];
+    for (const id of await this.listUnitWorkItemDirectories(unitId)) {
+      ids.add(id);
+    }
+    for (const id of await this.listCrossWorkItemDirectories()) {
+      ids.add(id);
     }
 
+    return [...ids].sort();
+  }
+
+  private async listUnitWorkItemDirectories(unitId: string): Promise<readonly string[]> {
+    const unitDir = path.join(this.rootDir, this.inceptionRoot, unitId);
+    const entries = await this.readDirectories(unitDir);
+
+    return entries
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => entry.name)
+      .filter((name) => !name.startsWith("_") && !name.startsWith("."))
+      .sort();
+  }
+
+  private async listCrossWorkItemDirectories(): Promise<readonly string[]> {
+    const crossDir = path.join(this.rootDir, this.inceptionRoot, "_cross");
+    const entries = await this.readDirectories(crossDir);
+
     return entries
       .filter((entry) => entry.isDirectory())
       .map((entry) => entry.name)
-      .filter((name) => !name.startsWith('_') && !name.startsWith('.'))
+      .filter((name) => CROSS_WORK_ITEM_PATTERN.test(name))
       .sort();
   }
 
+  private async readDirectories(dir: string): Promise<readonly Dirent[]> {
+    try {
+      return await readdir(dir, { withFileTypes: true });
+    } catch {
+      return [];
+    }
+  }
+
   async fileExists(relativePath: string): Promise<boolean> {
     const absolutePath = path.join(this.rootDir, relativePath);
     try {
@@ -58,37 +92,121 @@ export class FileSystemStoryReflectionAdapter
     }
   }
 
-  async fileContainsStoryAnnotation(
-    productPath: string,
-    storyId: string,
-  ): Promise<boolean> {
+  async storyAffectsUnit(storyId: string, unitId: string): Promise<boolean> {
+    if (!CROSS_WORK_ITEM_PATTERN.test(storyId)) {
+      return true;
+    }
+
+    let content: string;
+    try {
+      content = await readFile(
+        path.join(this.rootDir, this.inceptionRoot, "_cross", storyId, "description.md"),
+        "utf8",
+      );
+    } catch {
+      return true;
+    }
+
+    const frontmatter = FRONTMATTER_PATTERN.exec(content)?.[1];
+    if (frontmatter === undefined) {
+      return true;
+    }
+
+    const affects = AFFECTS_INLINE_PATTERN.exec(frontmatter)?.[1]
+      .split(",")
+      .map((value) => value.trim())
+      .filter((value) => value.length > 0);
+
+    if (affects === undefined) {
+      return true;
+    }
+
+    return affects.includes(unitId);
+  }
+
+  async fileContainsStoryAnnotation(productPath: string, storyId: string): Promise<boolean> {
     const absolutePath = path.join(this.rootDir, productPath);
 
     let content: string;
     try {
-      content = await readFile(absolutePath, 'utf8');
+      content = await readFile(absolutePath, "utf8");
     } catch {
       return false;
     }
 
-    // `@story-id` の直後にカンマ/空白区切りで列挙される story ID を抽出。
-    // 例: `@story-id US-001`, `@story-id US-001, US-002`,
-    //     `<!-- @story-id US-001 -->`
-    // 行末または `-->` まで（story ID 自体の `-` は許容するため `-->` を明示終端に使う）。
-    const pattern = /@story-id[ \t]+([^\n\r]+)/g;
-    let match: RegExpExecArray | null;
-    while ((match = pattern.exec(content)) !== null) {
+    // `@story-id` / `@issue-id` / `@work-item-id` 直後にカンマ/空白区切りで
+    // 列挙される ID を抽出。
+    // 例: `@story-id US-001`, `@work-item-id WI-001, WI-002`,
+    //     `<!-- @issue-id ISSUE-026 -->`
+    // capture[1] がアノテーション種別（未使用・将来拡張用）、capture[2] が ID 本体。
+    // 行末または `-->` まで（ID 自体の `-` を許容するため `-->` を明示終端に使う）。
+    const annotationIds = this.extractAnnotationIds(content);
+    if (annotationIds.includes(storyId)) {
+      return true;
+    }
+
+    const legacyId = await this.readLegacyId(storyId);
+    return legacyId !== null && annotationIds.includes(legacyId);
+  }
+
+  private extractAnnotationIds(content: string): readonly string[] {
+    const ids: string[] = [];
+
+    const annotationPattern = /@(story-id|issue-id|work-item-id)[ \t]+([^\n\r]+)/g;
+    let match = annotationPattern.exec(content);
+    while (match !== null) {
       // `-->` 以降の HTML コメント閉じ記号を取り除く
-      const raw = match[1].replace(/-->.*$/, '');
-      const ids = raw
-        .split(/[\s,]+/)
-        .map((s) => s.trim())
-        .filter((s) => s.length > 0);
-      if (ids.includes(storyId)) {
-        return true;
-      }
+      const raw = match[2].replace(/-->.*$/, "");
+      ids.push(
+        ...raw
+          .split(/[\s,]+/)
+          .map((s) => s.trim())
+          .filter((s) => s.length > 0),
+      );
+      match = annotationPattern.exec(content);
     }
 
-    return false;
+    return ids;
+  }
+
+  private async readLegacyId(storyId: string): Promise<string | null> {
+    if (!CROSS_WORK_ITEM_PATTERN.test(storyId)) {
+      return null;
+    }
+
+    for (const candidate of await this.listDescriptionCandidates(storyId)) {
+      const legacyId = await this.tryReadLegacyId(candidate);
+      if (legacyId !== null) return legacyId;
+    }
+
+    return null;
+  }
+
+  private async listDescriptionCandidates(storyId: string): Promise<readonly string[]> {
+    const inceptionDir = path.join(this.rootDir, this.inceptionRoot);
+    const candidates: string[] = [path.join(inceptionDir, "_cross", storyId, "description.md")];
+
+    for (const entry of await this.readDirectories(inceptionDir)) {
+      if (!entry.isDirectory()) continue;
+      const name = entry.name;
+      if (name.startsWith("_") || name.startsWith(".") || name === "issues") continue;
+      candidates.push(path.join(inceptionDir, name, storyId, "description.md"));
+    }
+
+    return candidates;
+  }
+
+  private async tryReadLegacyId(absolutePath: string): Promise<string | null> {
+    let content: string;
+    try {
+      content = await readFile(absolutePath, "utf8");
+    } catch {
+      return null;
+    }
+
+    const frontmatter = FRONTMATTER_PATTERN.exec(content)?.[1];
+    if (frontmatter === undefined) return null;
+
+    return LEGACY_ID_PATTERN.exec(frontmatter)?.[1] ?? null;
   }
 }