phasegate 0.83.0 → 0.107.0

package/scripts/harness/traceability-model/presentation/cli/migrate-work-items-command-handler.ts

@@ -0,0 +1,186 @@
+// @unit traceability-model
+// @layer presentation
+
+import type { ApplyWorkItemMigrationUseCase } from "../../application/usecases/apply-work-item-migration-usecase.js";
+import type { PlanWorkItemMigrationUseCase } from "../../application/usecases/plan-work-item-migration-usecase.js";
+import type {
+  WorkItemMigrationApplyResult,
+  WorkItemMigrationCandidate,
+  WorkItemMigrationPlan,
+} from "../../domain/value-objects/work-item-migration-candidate.js";
+
+export interface MigrateWorkItemsCommandInput {
+  readonly dryRun?: boolean;
+  readonly apply?: boolean;
+  readonly json?: boolean;
+}
+
+export interface MigrateWorkItemsCommandOutput {
+  readonly exitCode: 0 | 1 | 2;
+  readonly text: string;
+}
+
+type PlanUseCase = Pick<PlanWorkItemMigrationUseCase, "execute">;
+type ApplyUseCase = Pick<ApplyWorkItemMigrationUseCase, "execute">;
+
+export interface MigrateWorkItemsCommandHandlerDeps {
+  readonly planWorkItemMigrationUseCase: PlanUseCase;
+  readonly applyWorkItemMigrationUseCase?: ApplyUseCase;
+}
+
+export class MigrateWorkItemsCommandHandler {
+  private readonly planUseCase: PlanUseCase;
+  private readonly applyUseCase?: ApplyUseCase;
+
+  constructor(deps: MigrateWorkItemsCommandHandlerDeps) {
+    this.planUseCase = deps.planWorkItemMigrationUseCase;
+    this.applyUseCase = deps.applyWorkItemMigrationUseCase;
+  }
+
+  async execute(input: MigrateWorkItemsCommandInput): Promise<Readonly<MigrateWorkItemsCommandOutput>> {
+    if (input.apply && input.dryRun) {
+      return Object.freeze({
+        exitCode: 2,
+        text: "Error: --apply and --dry-run cannot be used together.",
+      });
+    }
+
+    if (input.apply) {
+      return this.executeApply(input);
+    }
+
+    if (!input.dryRun) {
+      return Object.freeze({
+        exitCode: 2,
+        text: "Error: either --dry-run or --apply is required for migrate work-items.",
+      });
+    }
+
+    try {
+      const plan = await this.planUseCase.execute();
+      const hasConflict = plan.candidates.some((candidate) => candidate.conflict);
+      return Object.freeze({
+        exitCode: hasConflict ? 1 : 0,
+        text: input.json ? this.formatJson(plan) : this.formatHuman(plan),
+      });
+    } catch {
+      return Object.freeze({
+        exitCode: 2,
+        text: "Error: failed to plan work item migration unexpectedly.",
+      });
+    }
+  }
+
+  private formatJson(plan: WorkItemMigrationPlan): string {
+    return JSON.stringify(
+      {
+        candidates: plan.candidates,
+        warnings: plan.warnings,
+      },
+      null,
+      2,
+    );
+  }
+
+  private async executeApply(input: MigrateWorkItemsCommandInput): Promise<Readonly<MigrateWorkItemsCommandOutput>> {
+    if (!this.applyUseCase) {
+      return Object.freeze({
+        exitCode: 2,
+        text: "Error: --apply is not configured for migrate work-items.",
+      });
+    }
+
+    try {
+      const result = await this.applyUseCase.execute();
+      return Object.freeze({
+        exitCode: result.blocked ? 1 : 0,
+        text: input.json ? this.formatApplyJson(result) : this.formatApplyHuman(result),
+      });
+    } catch {
+      return Object.freeze({
+        exitCode: 2,
+        text: "Error: failed to apply work item migration unexpectedly.",
+      });
+    }
+  }
+
+  private formatApplyJson(result: WorkItemMigrationApplyResult): string {
+    return JSON.stringify(
+      {
+        applied: result.applied,
+        skipped: result.skipped,
+        warnings: result.warnings,
+        blocked: result.blocked,
+      },
+      null,
+      2,
+    );
+  }
+
+  private formatApplyHuman(result: WorkItemMigrationApplyResult): string {
+    const lines = [
+      "WorkItem migration apply",
+      `applied: ${result.applied.length}`,
+      `skipped: ${result.skipped.length}`,
+      `warnings: ${result.warnings.length}`,
+      `blocked: ${result.blocked ? "yes" : "no"}`,
+      "",
+    ];
+
+    for (const applied of result.applied) {
+      lines.push(`- applied ${applied.legacyId} -> ${applied.nextId}`);
+      lines.push(`  target: ${applied.targetPath}`);
+      lines.push(`  description: ${applied.descriptionPath}`);
+      lines.push("");
+    }
+
+    for (const skipped of result.skipped) {
+      lines.push(`- skipped ${skipped.legacyId} -> ${skipped.nextId}`);
+      lines.push(`  reason: conflict`);
+      lines.push(`  target: ${skipped.targetPath}`);
+      lines.push("");
+    }
+
+    if (result.warnings.length > 0) {
+      lines.push("Warnings:");
+      for (const warning of result.warnings) {
+        lines.push(`  - ${warning}`);
+      }
+    }
+
+    return lines.join("\n").trimEnd();
+  }
+
+  private formatHuman(plan: WorkItemMigrationPlan): string {
+    const lines = [
+      "WorkItem migration dry-run",
+      `candidates: ${plan.candidates.length}`,
+      `warnings: ${plan.warnings.length}`,
+      "",
+    ];
+
+    for (const candidate of plan.candidates) {
+      lines.push(...this.formatCandidate(candidate), "");
+    }
+
+    if (plan.warnings.length > 0) {
+      lines.push("Warnings:");
+      for (const warning of plan.warnings) {
+        lines.push(`  - ${warning}`);
+      }
+    }
+
+    return lines.join("\n").trimEnd();
+  }
+
+  private formatCandidate(candidate: WorkItemMigrationCandidate): string[] {
+    return [
+      `- ${candidate.legacyId} -> ${candidate.nextId}`,
+      `  source: ${candidate.sourcePath}`,
+      `  target: ${candidate.targetPath}`,
+      `  scope: ${candidate.scope}`,
+      `  description: ${candidate.descriptionFileName ?? "missing"}`,
+      `  conflict: ${candidate.conflict ? "yes" : "no"}`,
+    ];
+  }
+}

package/skills/quick-implementor/SKILL.md

@@ -18,6 +18,20 @@ Quick Mode下での軽微変更実装スキル。story-implementorの緩和版
 | `test` | テスト追加・修正（新機能のテストではない） |
 | `config` | 設定変更、依存バージョン更新 |
 
+### WI-aware trivial path（ISSUE-026 Phase D）
+
+作業対象に `WI-XXX` が明示されている場合、最初に `docs/inception/{unit}/WI-XXX/description.md` または `docs/inception/_cross/WI-XXX/description.md` のfrontmatterを確認する。
+
+| WI type | Quick Modeでの扱い |
+|---------|-------------------|
+| `fix` | 適用候補。既存仕様の局所修正として扱う |
+| `chore` | 適用候補。依存更新・運用・ドキュメント整備として扱う |
+| `story` | 適用不可。`story-implementor` にエスカレーション |
+| `issue` | 適用不可。product反映が必要な可能性が高いため `story-implementor` にエスカレーション |
+| `refactor` | 適用不可。設計影響を伴う可能性が高いため `story-implementor` にエスカレーション |
+
+`type: fix | chore` でも、API契約変更・新ドメインモデル追加・レイヤー構造変更・複数Unitにまたがる実装変更が見えた場合は、通常の除外ルールを優先して `story-implementor` に切り替える。
+
 ### 適用除外（フルハーネス必須 → story-implementor を使用）
 
 - 新機能追加
@@ -82,10 +96,12 @@ pnpm test  # 全テスト グリーンを確認
 
 ### Step 5: コミット
 
-Atomic commit で変更をコミットする。コミットメッセージに `[quick]` プレフィックスを付与。
+Atomic commit で変更をコミットする。コミットメッセージに `[quick]` プレフィックスを付与。作業対象WIがある場合は `Work-Item: WI-XXX` trailer を必ず含める。
 
 ```
 [quick] fix: {変更内容の要約}
+
+Work-Item: WI-XXX
 ```
 
 ---

package/templates/.husky/commit-msg

@@ -0,0 +1 @@
+npx phasegate commit-msg "$1"

package/scripts/harness/adr-foundation/application/dto/seed-adr-definition.ts

@@ -1,21 +0,0 @@
-/**
- * @layer application
- * @unit adr-foundation
- */
-export interface SeedAdrDefinition {
-  readonly title: string;
-  readonly status: 'Proposed' | 'Accepted' | 'Deprecated' | 'Superseded';
-  readonly date: string;
-  readonly body: {
-    readonly context: string;
-    readonly decision: string;
-    readonly consequences: string;
-    readonly alternatives?: string;
-  };
-  readonly archgate?: {
-    readonly enforcedBy: ReadonlyArray<{
-      readonly validatorId: string;
-      readonly errorCode: string;
-    }>;
-  };
-}

package/scripts/harness/adr-foundation/application/usecases/seed-initial-adrs-use-case.ts

@@ -1,84 +0,0 @@
-/**
- * @layer application
- * @unit adr-foundation
- */
-import { ADR } from '../../domain/aggregates/adr.js';
-import type { AdrDocumentParserPort } from '../../domain/ports/adr-document-parser-port.js';
-import type { AdrRepositoryPort } from '../../domain/ports/adr-repository-port.js';
-import { AdrValidationService } from '../../domain/services/adr-validation-service.js';
-import { AdrId } from '../../domain/value-objects/adr-id.js';
-import {
-  DuplicateAdrIdApplicationError,
-  SeedAdrDefinitionCountError,
-} from '../dto/application-errors.js';
-import type { SeedAdrDefinition } from '../dto/seed-adr-definition.js';
-
-export interface SeedInitialAdrsInput {
-  readonly definitions: SeedAdrDefinition[];
-  readonly overwrite?: boolean;
-}
-
-export interface SeedInitialAdrsOutput {
-  readonly created: readonly string[];
-  readonly skipped: readonly string[];
-}
-
-export class SeedInitialAdrsUseCase {
-  constructor(
-    private readonly adrRepository: AdrRepositoryPort,
-    private readonly documentParser: AdrDocumentParserPort,
-  ) {}
-
-  async execute(input: SeedInitialAdrsInput): Promise<Readonly<SeedInitialAdrsOutput>> {
-    if (input.definitions.length !== 11) {
-      throw new SeedAdrDefinitionCountError(input.definitions.length);
-    }
-
-    const created: string[] = [];
-    const skipped: string[] = [];
-
-    for (const [index, definition] of input.definitions.entries()) {
-      const adrId = AdrId.create(String(index + 1).padStart(3, '0'));
-      const adrRef = adrId.toAdrRef();
-
-      if (created.includes(adrRef) || skipped.includes(adrRef)) {
-        throw new DuplicateAdrIdApplicationError(adrRef);
-      }
-
-      const adr = ADR.create(
-        {
-          adr_id: adrId.value,
-          title: definition.title,
-          status: definition.status,
-          date: definition.date,
-          archgate: definition.archgate
-            ? {
-                adr_id: adrId.value,
-                enforced_by: definition.archgate.enforcedBy.map((entry) => ({
-                  validator_id: entry.validatorId,
-                  error_code: entry.errorCode,
-                })),
-              }
-            : undefined,
-        },
-        definition.body,
-        new AdrValidationService(),
-      );
-
-      const exists = await this.adrRepository.exists(adrId);
-      if (exists && input.overwrite !== true) {
-        skipped.push(adrRef);
-        continue;
-      }
-
-      this.documentParser.serializeDocument(adr);
-      await this.adrRepository.save(adr);
-      created.push(adrRef);
-    }
-
-    return Object.freeze({
-      created: Object.freeze(created),
-      skipped: Object.freeze(skipped),
-    });
-  }
-}

package/scripts/harness/adr-foundation/infrastructure/seeds/initial-adr-definitions.ts

@@ -1,161 +0,0 @@
-/**
- * @layer infrastructure
- * @unit adr-foundation
- */
-import type { SeedAdrDefinition } from '../../application/dto/seed-adr-definition.js';
-
-export const INITIAL_ADR_DEFINITIONS: readonly SeedAdrDefinition[] = [
-  {
-    title: 'Package separation',
-    status: 'Accepted',
-    date: '2026-03-13',
-    body: {
-      context:
-        'The harness codebase has grown beyond a single-package structure. Build times increase and cross-cutting changes create unnecessary coupling.',
-      decision:
-        'Separate the repository into discrete packages aligned with bounded contexts, each with its own build and test lifecycle.',
-      consequences:
-        'Packages can evolve independently. CI must orchestrate multi-package builds. Shared kernel contracts must be explicitly published.',
-    },
-  },
-  {
-    title: 'Full migration from ESLint to Biome',
-    status: 'Accepted',
-    date: '2026-03-13',
-    body: {
-      context:
-        'The project currently uses ESLint for linting. Biome offers faster execution and unified formatting with linting in a single tool.',
-      decision:
-        'Migrate all linting and formatting from ESLint and Prettier to Biome as the sole toolchain.',
-      consequences:
-        'Tooling becomes simpler and faster. Custom ESLint rules must be re-implemented as Biome plugins or GritQL patterns.',
-      alternatives:
-        'Keep dual toolchain with ESLint for rules not yet supported by Biome.',
-    },
-  },
-  {
-    title: 'Quality harness owns K1-K13',
-    status: 'Accepted',
-    date: '2026-03-13',
-    body: {
-      context:
-        'Quality indicators K1 through K13 are defined across multiple documents with no single owner enforcing them.',
-      decision:
-        'The quality harness unit owns the enforcement of all K1-K13 indicators, providing validators and gates for each.',
-      consequences:
-        'A single unit is accountable for quality enforcement. Other units must integrate through the harness contract rather than implementing ad-hoc checks.',
-    },
-  },
-  {
-    title: 'FUSE Hooks Engine is out of v1 scope',
-    status: 'Proposed',
-    date: '2026-03-13',
-    body: {
-      context:
-        'The FUSE Hooks Engine provides extensible event-driven hooks but adds significant complexity to the initial delivery.',
-      decision:
-        'Defer the FUSE Hooks Engine to a post-v1 phase. The v1 harness will use direct invocation patterns.',
-      consequences:
-        'Reduced initial scope and risk. Hook-based extensibility will require a migration path when introduced later.',
-      alternatives:
-        'Include a minimal hooks engine in v1 with limited extensibility.',
-    },
-  },
-  {
-    title: 'HarnessError requires fix_example',
-    status: 'Accepted',
-    date: '2026-03-13',
-    body: {
-      context:
-        'Developers receiving harness errors often lack actionable guidance on how to resolve violations.',
-      decision:
-        'Every HarnessError definition must include a fix_example field demonstrating the corrective action.',
-      consequences:
-        'Error definitions are more verbose but significantly more useful. All existing error definitions must be updated to include examples.',
-    },
-  },
-  {
-    title: 'Strict quick mode eligibility',
-    status: 'Accepted',
-    date: '2026-03-13',
-    body: {
-      context:
-        'Quick mode bypasses expensive validators but must not compromise quality gates for critical changes.',
-      decision:
-        'Define strict eligibility criteria for quick mode based on file change scope and affected layers.',
-      consequences:
-        'Quick mode runs faster for eligible changes. Complex cross-layer changes always run the full validator stack.',
-      alternatives:
-        'Allow developers to manually opt into quick mode regardless of change scope.',
-    },
-  },
-  {
-    title: 'Separate config files',
-    status: 'Accepted',
-    date: '2026-03-13',
-    body: {
-      context:
-        'A single monolithic configuration file makes it difficult to manage unit-specific settings and increases merge conflicts.',
-      decision:
-        'Split configuration into separate files per concern: phasegate.config.json for core settings, with unit-specific overrides.',
-      consequences:
-        'Configuration is modular and easier to maintain. The config loader must implement a merge strategy for layered configs.',
-    },
-  },
-  {
-    title: 'Nyquist integration for truths and artifacts',
-    status: 'Proposed',
-    date: '2026-03-13',
-    body: {
-      context:
-        'Nyquist provides a truth-source registry and artifact tracking system that could centralize harness state management.',
-      decision:
-        'Integrate with Nyquist for truth registration and artifact lifecycle tracking.',
-      consequences:
-        'Harness gains a centralized truth source. A dependency on Nyquist availability is introduced.',
-      alternatives:
-        'Build a standalone truth registry within the harness codebase.',
-    },
-  },
-  {
-    title: 'Artifact-driven state derivation',
-    status: 'Accepted',
-    date: '2026-03-13',
-    body: {
-      context:
-        'Harness state is currently computed on-the-fly, leading to inconsistent results across different invocation points.',
-      decision:
-        'Derive harness state exclusively from persisted artifacts, making state deterministic and reproducible.',
-      consequences:
-        'State becomes auditable and cacheable. All state-changing operations must produce artifacts as their primary output.',
-    },
-  },
-  {
-    title: 'Validator stack detection',
-    status: 'Accepted',
-    date: '2026-03-13',
-    body: {
-      context:
-        'Validators are registered individually, but their execution order and dependencies are not explicitly managed.',
-      decision:
-        'Implement automatic validator stack detection that resolves execution order based on declared dependencies and layer constraints.',
-      consequences:
-        'Validator execution order is deterministic and verifiable. Circular dependencies are detected at registration time.',
-    },
-  },
-  {
-    title: 'Temporary 4-layer definition with return path to 5-layer',
-    status: 'Proposed',
-    date: '2026-03-13',
-    body: {
-      context:
-        'The target architecture defines 5 layers, but the current codebase structure and team familiarity support only 4 layers.',
-      decision:
-        'Adopt a temporary 4-layer definition (domain, application, infrastructure, presentation) with a documented return path to the 5-layer target.',
-      consequences:
-        'Initial implementation is simpler. The migration plan to 5 layers must be maintained and reviewed periodically.',
-      alternatives:
-        'Adopt the full 5-layer structure from the start despite the complexity cost.',
-    },
-  },
-] as const;