phasegate 0.15.0

package/scripts/harness/harness-error/infrastructure/adapters/validator-execution-fix-example-validator-adapter.ts

@@ -0,0 +1,141 @@
+/**
+ * @layer infrastructure
+ * @unit harness-error
+ */
+import type { FixExampleValidatorPort } from '../../domain/ports/fix-example-validator-port.js';
+import { FixExampleValidationResult } from '../../domain/value-objects/fix-example-validation-result.js';
+import type {
+  ValidatorEntrypoint,
+  ValidatorIssueSnapshot,
+} from './validator-registry-bridge-adapter.js';
+import { ValidatorRegistryBridgeAdapter } from './validator-registry-bridge-adapter.js';
+import { TypeScriptSnippetSyntaxAdapter } from './type-script-snippet-syntax-adapter.js';
+
+export type { ValidatorEntrypoint } from './validator-registry-bridge-adapter.js';
+
+export interface ValidatorExecutionFixExampleValidatorAdapterDeps {
+  readonly syntaxAdapter: TypeScriptSnippetSyntaxAdapter;
+  readonly validatorRegistryBridge: ValidatorRegistryBridgeAdapter;
+}
+
+export class ValidatorExecutionFixExampleValidatorAdapter
+  implements FixExampleValidatorPort
+{
+  private readonly syntaxAdapter: TypeScriptSnippetSyntaxAdapter;
+  private readonly validatorRegistryBridge: ValidatorRegistryBridgeAdapter;
+
+  constructor(deps: ValidatorExecutionFixExampleValidatorAdapterDeps) {
+    this.syntaxAdapter = deps.syntaxAdapter;
+    this.validatorRegistryBridge = deps.validatorRegistryBridge;
+  }
+
+  async validate(input: {
+    validatorId: string;
+    errorCode: { toString(): string };
+    fixExample: { toString(): string };
+  }): Promise<FixExampleValidationResult> {
+    const syntaxResult = this.syntaxAdapter.validate(input.fixExample.toString());
+    const entrypoint = this.validatorRegistryBridge.resolve(input.validatorId);
+    const validatorResult = await entrypoint.validateFixExample({
+      validatorId: input.validatorId,
+      errorCode: input.errorCode.toString(),
+      fixExample: input.fixExample.toString(),
+    });
+
+    const diagnostics = [
+      ...this.buildSyntaxDiagnostics(syntaxResult.diagnostics),
+      ...this.buildFixtureDiagnostics(
+        input.errorCode.toString(),
+        validatorResult.beforeIssues
+      ),
+      ...this.buildValidatorDiagnostics(
+        input.errorCode.toString(),
+        validatorResult.afterIssues
+      ),
+    ];
+
+    const targetIssueDetectedBefore = validatorResult.beforeIssues.some(
+      (issue) => issue.code === input.errorCode.toString()
+    );
+    const targetIssueRemains = validatorResult.afterIssues.some(
+      (issue) => issue.code === input.errorCode.toString()
+    );
+    const additionalIssues = validatorResult.afterIssues.some(
+      (issue) => issue.code !== input.errorCode.toString()
+    );
+
+    if (
+      syntaxResult.valid &&
+      targetIssueDetectedBefore &&
+      !targetIssueRemains &&
+      !additionalIssues
+    ) {
+      return FixExampleValidationResult.success(input.validatorId);
+    }
+
+    const reason = this.resolveFailureReason(
+      syntaxResult.valid,
+      targetIssueDetectedBefore,
+      targetIssueRemains,
+      additionalIssues
+    );
+
+    return FixExampleValidationResult.failure(
+      input.validatorId,
+      reason,
+      diagnostics
+    );
+  }
+
+  private buildSyntaxDiagnostics(
+    diagnostics: readonly string[]
+  ): readonly string[] {
+    return diagnostics.map((diagnostic) => `構文エラー: ${diagnostic}`);
+  }
+
+  private buildFixtureDiagnostics(
+    targetCode: string,
+    issues: readonly ValidatorIssueSnapshot[]
+  ): readonly string[] {
+    const found = issues.some((issue) => issue.code === targetCode);
+    if (found) {
+      return [];
+    }
+    return [`fixture不足: ${targetCode} を再現できませんでした。`];
+  }
+
+  private buildValidatorDiagnostics(
+    targetCode: string,
+    issues: readonly ValidatorIssueSnapshot[]
+  ): readonly string[] {
+    return issues.map((issue) =>
+      issue.code === targetCode
+        ? `validator失敗: ${issue.message}`
+        : `追加検出: ${issue.code} ${issue.message}`
+    );
+  }
+
+  private resolveFailureReason(
+    syntaxValid: boolean,
+    targetIssueDetectedBefore: boolean,
+    targetIssueRemains: boolean,
+    additionalIssues: boolean
+  ): string {
+    if (!targetIssueDetectedBefore) {
+      return 'fixture上で対象コードの違反を再現できませんでした。';
+    }
+    if (!syntaxValid && targetIssueRemains) {
+      return '構文エラーがあり、対象コードの違反も残っています。';
+    }
+    if (!syntaxValid) {
+      return '構文エラーが存在します。';
+    }
+    if (targetIssueRemains) {
+      return 'fix_example適用後も対象コードの違反が残っています。';
+    }
+    if (additionalIssues) {
+      return 'fix_example適用後に別コードの違反が追加されています。';
+    }
+    return 'fix_exampleの検証に失敗しました。';
+  }
+}

package/scripts/harness/harness-error/infrastructure/adapters/validator-registry-bridge-adapter.ts

@@ -0,0 +1,101 @@
+/**
+ * @layer infrastructure
+ * @unit harness-error
+ */
+export interface ValidatorIssueSnapshot {
+  readonly code: string;
+  readonly message: string;
+}
+
+export interface ValidatorFixExampleExecutionResult {
+  readonly beforeIssues: readonly ValidatorIssueSnapshot[];
+  readonly afterIssues: readonly ValidatorIssueSnapshot[];
+}
+
+export interface ValidatorEntrypoint {
+  validateFixExample(input: {
+    validatorId: string;
+    errorCode: string;
+    fixExample: string;
+  }): Promise<ValidatorFixExampleExecutionResult>;
+}
+
+function createDefaultEntrypoint(validatorId: string): ValidatorEntrypoint {
+  return {
+    async validateFixExample(input) {
+      const beforeIssues = Object.freeze([
+        Object.freeze({
+          code: input.errorCode,
+          message: `${validatorId} detected ${input.errorCode} before fix application.`,
+        }),
+      ]);
+
+      const looksBroken =
+        input.fixExample.includes('= ;') ||
+        input.fixExample.includes('broken');
+
+      const afterIssues = looksBroken
+        ? Object.freeze([
+            Object.freeze({
+              code: input.errorCode,
+              message: `${validatorId} still detects ${input.errorCode} after fix application.`,
+            }),
+          ])
+        : Object.freeze([]);
+
+      return Object.freeze({
+        beforeIssues,
+        afterIssues,
+      });
+    },
+  };
+}
+
+const DEFAULT_VALIDATOR_IDS = [
+  'phase-gate',
+  'metadata',
+  'test-quality',
+  'security',
+  'performance',
+  'coverage',
+  'nyquist',
+  'architecture',
+  'dependency',
+  'drift-detect',
+  'consistency-check',
+  'dead-code',
+] as const;
+
+export const DEFAULT_VALIDATOR_ENTRYPOINTS = new Map<
+  string,
+  ValidatorEntrypoint
+>(
+  DEFAULT_VALIDATOR_IDS.map((validatorId) => [
+    validatorId,
+    createDefaultEntrypoint(validatorId),
+  ])
+);
+
+export interface ValidatorRegistryBridgeAdapterDeps {
+  readonly entrypoints?: ReadonlyMap<string, ValidatorEntrypoint>;
+}
+
+export class ValidatorRegistryBridgeAdapter {
+  private readonly entrypoints: ReadonlyMap<string, ValidatorEntrypoint>;
+
+  constructor(deps: ValidatorRegistryBridgeAdapterDeps = {}) {
+    this.entrypoints = deps.entrypoints ?? DEFAULT_VALIDATOR_ENTRYPOINTS;
+  }
+
+  resolve(validatorId: string): ValidatorEntrypoint {
+    const entrypoint = this.entrypoints.get(validatorId);
+    if (!entrypoint) {
+      throw new Error(`未知のvalidatorIdです: ${validatorId}`);
+    }
+    return entrypoint;
+  }
+
+  getRegisteredValidatorIds(): readonly string[] {
+    return Object.freeze([...this.entrypoints.keys()]);
+  }
+}

package/scripts/harness/harness-error/infrastructure/registry/build-error-definition-registry.ts

@@ -0,0 +1,40 @@
+/**
+ * @layer infrastructure
+ * @unit harness-error
+ */
+import { InvalidErrorDefinitionError } from '../../domain/errors/invalid-error-definition-error.js';
+import { ErrorDefinitionRegistry } from '../../domain/services/error-definition-registry.js';
+import type { ErrorDefinition } from '../../domain/value-objects/error-definition.js';
+
+function flattenDefinitions(
+  definitions: readonly (readonly ErrorDefinition[])[]
+): readonly ErrorDefinition[] {
+  return definitions.flat();
+}
+
+function assertStartupInvariants(definitions: readonly ErrorDefinition[]): void {
+  for (const definition of definitions) {
+    if (definition.adrRefRequired && definition.defaultAdrRef === null) {
+      throw new InvalidErrorDefinitionError(
+        `adrRefRequired=true のため defaultAdrRef が必須です: ${definition.code.toString()}`
+      );
+    }
+
+    if (
+      definition.fixExampleRequired &&
+      definition.defaultFixExample === null
+    ) {
+      throw new InvalidErrorDefinitionError(
+        `fixExampleRequired=true のため defaultFixExample が必須です: ${definition.code.toString()}`
+      );
+    }
+  }
+}
+
+export function buildErrorDefinitionRegistry(
+  definitions: readonly (readonly ErrorDefinition[])[]
+): ErrorDefinitionRegistry {
+  const flattenedDefinitions = flattenDefinitions(definitions);
+  assertStartupInvariants(flattenedDefinitions);
+  return new ErrorDefinitionRegistry(flattenedDefinitions);
+}

package/scripts/harness/harness-error/infrastructure/registry/l1-error-definitions.ts

@@ -0,0 +1,90 @@
+/**
+ * @layer infrastructure
+ * @unit harness-error
+ */
+import { AdrRef } from '../../domain/value-objects/adr-ref.js';
+import { ErrorCode } from '../../domain/value-objects/error-code.js';
+import { ErrorDefinition } from '../../domain/value-objects/error-definition.js';
+import { FixExample } from '../../domain/value-objects/fix-example.js';
+import { Severity } from '../../domain/value-objects/severity.js';
+
+function createDefinition(input: {
+  code: string;
+  title: string;
+  category: 'phase_gate' | 'architecture' | 'dependency' | 'quality' | 'security' | 'performance' | 'consistency' | 'metadata';
+  ownerValidatorId: string;
+  defaultFixExample: string;
+}): ErrorDefinition {
+  return ErrorDefinition.create({
+    code: ErrorCode.create(input.code),
+    title: input.title,
+    category: input.category,
+    defaultSeverity: Severity.create('error'),
+    adrRefRequired: true,
+    defaultAdrRef: AdrRef.create('ADR-001'),
+    fixExampleRequired: true,
+    defaultFixExample: FixExample.create(input.defaultFixExample),
+    ownerValidatorId: input.ownerValidatorId,
+  });
+}
+
+export const L1_ERROR_DEFINITIONS = Object.freeze([
+  createDefinition({
+    code: 'L1-001',
+    title: '@unit コメントが不足している',
+    category: 'metadata',
+    ownerValidatorId: 'metadata',
+    defaultFixExample: '/** @unit harness-error */\nconst actual = true;',
+  }),
+  createDefinition({
+    code: 'L1-002',
+    title: '@layer コメントが不足している',
+    category: 'metadata',
+    ownerValidatorId: 'metadata',
+    defaultFixExample: '/** @layer infrastructure */\nconst actual = true;',
+  }),
+  createDefinition({
+    code: 'L1-003',
+    title: 'レイヤー境界を越えるimportがある',
+    category: 'dependency',
+    ownerValidatorId: 'dependency',
+    defaultFixExample:
+      "import type { DependencyPort } from '../ports/dependency-port.js';\nconst actual = true;",
+  }),
+  createDefinition({
+    code: 'L1-004',
+    title: 'フォルダ構造がアーキテクチャ規約に違反している',
+    category: 'architecture',
+    ownerValidatorId: 'architecture',
+    defaultFixExample: "const destination = 'infrastructure/adapters';",
+  }),
+  createDefinition({
+    code: 'L1-005',
+    title: 'any型の乱用がある',
+    category: 'quality',
+    ownerValidatorId: 'architecture',
+    defaultFixExample: 'const actual: string = "fixed";',
+  }),
+  createDefinition({
+    code: 'L1-006',
+    title: '参照されないファイルが残っている',
+    category: 'architecture',
+    ownerValidatorId: 'architecture',
+    defaultFixExample: 'export const actual = "shared";',
+  }),
+  createDefinition({
+    code: 'L1-007',
+    title: 'コメント量が過剰である',
+    category: 'quality',
+    ownerValidatorId: 'architecture',
+    defaultFixExample: 'const actual = "keep comments concise";',
+  }),
+  createDefinition({
+    code: 'L1-008',
+    title: '重複コードが検出された',
+    category: 'architecture',
+    ownerValidatorId: 'architecture',
+    defaultFixExample:
+      'function buildValue(): string { return "shared"; }\nconst actual = buildValue();',
+  }),
+]);

package/scripts/harness/harness-error/infrastructure/registry/l2-error-definitions.ts

@@ -0,0 +1,56 @@
+/**
+ * @layer infrastructure
+ * @unit harness-error
+ */
+import { AdrRef } from '../../domain/value-objects/adr-ref.js';
+import { ErrorCode } from '../../domain/value-objects/error-code.js';
+import { ErrorDefinition } from '../../domain/value-objects/error-definition.js';
+import { FixExample } from '../../domain/value-objects/fix-example.js';
+import { Severity } from '../../domain/value-objects/severity.js';
+
+function createDefinition(input: {
+  code: string;
+  title: string;
+  category: 'phase_gate' | 'architecture' | 'dependency' | 'quality' | 'security' | 'performance' | 'consistency' | 'metadata';
+  ownerValidatorId: string;
+  defaultFixExample: string;
+}): ErrorDefinition {
+  return ErrorDefinition.create({
+    code: ErrorCode.create(input.code),
+    title: input.title,
+    category: input.category,
+    defaultSeverity: Severity.create('error'),
+    adrRefRequired: true,
+    defaultAdrRef: AdrRef.create('ADR-002'),
+    fixExampleRequired: true,
+    defaultFixExample: FixExample.create(input.defaultFixExample),
+    ownerValidatorId: input.ownerValidatorId,
+  });
+}
+
+export const L2_ERROR_DEFINITIONS = Object.freeze([
+  createDefinition({
+    code: 'L2-001',
+    title: 'Phase Gate の前提条件に違反している',
+    category: 'phase_gate',
+    ownerValidatorId: 'phase-gate',
+    defaultFixExample:
+      "const requiredPlanPath = 'docs/inception/harness-error/it_test_logic_plan.md';",
+  }),
+  createDefinition({
+    code: 'L2-002',
+    title: 'メタデータが不足している',
+    category: 'metadata',
+    ownerValidatorId: 'metadata',
+    defaultFixExample:
+      '/**\n * @unit harness-error\n * @layer infrastructure\n */\nconst actual = true;',
+  }),
+  createDefinition({
+    code: 'L2-003',
+    title: 'テスト品質規約に違反している',
+    category: 'quality',
+    ownerValidatorId: 'test-quality',
+    defaultFixExample:
+      "const actual = sut.execute();\nexpect(actual).toBeDefined();",
+  }),
+]);

package/scripts/harness/harness-error/infrastructure/registry/l3-error-definitions.ts

@@ -0,0 +1,61 @@
+/**
+ * @layer infrastructure
+ * @unit harness-error
+ */
+import { AdrRef } from '../../domain/value-objects/adr-ref.js';
+import { ErrorCode } from '../../domain/value-objects/error-code.js';
+import { ErrorDefinition } from '../../domain/value-objects/error-definition.js';
+import { FixExample } from '../../domain/value-objects/fix-example.js';
+import { Severity } from '../../domain/value-objects/severity.js';
+
+function createDefinition(input: {
+  code: string;
+  title: string;
+  category: 'phase_gate' | 'architecture' | 'dependency' | 'quality' | 'security' | 'performance' | 'consistency' | 'metadata';
+  ownerValidatorId: string;
+  defaultFixExample: string;
+}): ErrorDefinition {
+  return ErrorDefinition.create({
+    code: ErrorCode.create(input.code),
+    title: input.title,
+    category: input.category,
+    defaultSeverity: Severity.create('error'),
+    adrRefRequired: true,
+    defaultAdrRef: AdrRef.create('ADR-003'),
+    fixExampleRequired: true,
+    defaultFixExample: FixExample.create(input.defaultFixExample),
+    ownerValidatorId: input.ownerValidatorId,
+  });
+}
+
+export const L3_ERROR_DEFINITIONS = Object.freeze([
+  createDefinition({
+    code: 'L3-001',
+    title: 'セキュリティ上の問題が検出された',
+    category: 'security',
+    ownerValidatorId: 'security',
+    defaultFixExample: "const token = process.env.API_TOKEN ?? '';",
+  }),
+  createDefinition({
+    code: 'L3-002',
+    title: 'パフォーマンス上の問題が検出された',
+    category: 'performance',
+    ownerValidatorId: 'performance',
+    defaultFixExample:
+      'const actual = await Promise.all(tasks.map((task) => task()));',
+  }),
+  createDefinition({
+    code: 'L3-003',
+    title: 'カバレッジ閾値を下回っている',
+    category: 'quality',
+    ownerValidatorId: 'coverage',
+    defaultFixExample: 'const actualCoverage = 0.95;',
+  }),
+  createDefinition({
+    code: 'L3-004',
+    title: '要件とテストのトレーサビリティが不足している',
+    category: 'consistency',
+    ownerValidatorId: 'nyquist',
+    defaultFixExample: 'const storyId = "H06-01";',
+  }),
+]);

package/scripts/harness/harness-error/infrastructure/registry/l4-error-definitions.ts

@@ -0,0 +1,53 @@
+/**
+ * @layer infrastructure
+ * @unit harness-error
+ */
+import { AdrRef } from '../../domain/value-objects/adr-ref.js';
+import { ErrorCode } from '../../domain/value-objects/error-code.js';
+import { ErrorDefinition } from '../../domain/value-objects/error-definition.js';
+import { FixExample } from '../../domain/value-objects/fix-example.js';
+import { Severity } from '../../domain/value-objects/severity.js';
+
+function createDefinition(input: {
+  code: string;
+  title: string;
+  category: 'phase_gate' | 'architecture' | 'dependency' | 'quality' | 'security' | 'performance' | 'consistency' | 'metadata';
+  ownerValidatorId: string;
+  defaultFixExample: string;
+}): ErrorDefinition {
+  return ErrorDefinition.create({
+    code: ErrorCode.create(input.code),
+    title: input.title,
+    category: input.category,
+    defaultSeverity: Severity.create('warning'),
+    adrRefRequired: true,
+    defaultAdrRef: AdrRef.create('ADR-004'),
+    fixExampleRequired: true,
+    defaultFixExample: FixExample.create(input.defaultFixExample),
+    ownerValidatorId: input.ownerValidatorId,
+  });
+}
+
+export const L4_ERROR_DEFINITIONS = Object.freeze([
+  createDefinition({
+    code: 'L4-001',
+    title: '設計と実装の乖離が検出された',
+    category: 'consistency',
+    ownerValidatorId: 'drift-detect',
+    defaultFixExample: 'const actual = "align implementation with design";',
+  }),
+  createDefinition({
+    code: 'L4-002',
+    title: '文書間の整合性が崩れている',
+    category: 'consistency',
+    ownerValidatorId: 'consistency-check',
+    defaultFixExample: 'const actual = "synchronize documentation";',
+  }),
+  createDefinition({
+    code: 'L4-003',
+    title: '未使用コードが検出された',
+    category: 'consistency',
+    ownerValidatorId: 'dead-code',
+    defaultFixExample: 'const actual = "remove unused export";',
+  }),
+]);

package/scripts/harness/harness-error/presentation/formatters/agent-error-formatter.ts

@@ -0,0 +1,54 @@
+/**
+ * @layer presentation
+ * @unit harness-error
+ *
+ * HarnessErrorContract をAIエージェント向け構造化データに変換するフォーマッター
+ */
+import type { HarnessErrorContract } from '../../application/dto/harness-error-contract.js';
+
+export interface AgentErrorFormatterOutput {
+  readonly json: string;
+}
+
+export interface AgentErrorPayload {
+  readonly errors: readonly AgentErrorEntry[];
+  readonly summary: {
+    readonly total: number;
+    readonly errorCount: number;
+    readonly warningCount: number;
+  };
+}
+
+export interface AgentErrorEntry {
+  readonly code: string;
+  readonly severity: 'error' | 'warning';
+  readonly message: string;
+  readonly suggestion: string;
+  readonly adr_ref?: string;
+  readonly fix_example?: string;
+}
+
+export class AgentErrorFormatter {
+  format(errors: readonly HarnessErrorContract[]): AgentErrorFormatterOutput {
+    const payload: AgentErrorPayload = {
+      errors: errors.map((e) => {
+        const entry: AgentErrorEntry = {
+          code: e.code,
+          severity: e.severity,
+          message: e.message,
+          suggestion: e.suggestion,
+          ...(e.adr_ref !== undefined ? { adr_ref: e.adr_ref } : {}),
+          ...(e.fix_example !== undefined ? { fix_example: e.fix_example } : {}),
+        };
+        return entry;
+      }),
+      summary: {
+        total: errors.length,
+        errorCount: errors.filter((e) => e.severity === 'error').length,
+        warningCount: errors.filter((e) => e.severity === 'warning').length,
+      },
+    };
+
+    return { json: JSON.stringify(payload, null, 2) };
+  }
+}

package/scripts/harness/harness-error/presentation/formatters/ci-error-formatter.ts

@@ -0,0 +1,27 @@
+/**
+ * @layer presentation
+ * @unit harness-error
+ *
+ * HarnessErrorContract を GitHub Actions アノテーション形式に変換するフォーマッター
+ */
+import type { HarnessErrorContract } from '../../application/dto/harness-error-contract.js';
+
+export interface CiErrorFormatterOutput {
+  readonly text: string;
+}
+
+export class CiErrorFormatter {
+  format(errors: readonly HarnessErrorContract[]): CiErrorFormatterOutput {
+    if (errors.length === 0) {
+      return { text: '' };
+    }
+
+    const lines: string[] = errors.map((error) => {
+      const level = error.severity === 'error' ? 'error' : 'warning';
+      const title = `${error.code}: ${error.message}`;
+      return `::${level} title=${title}::${error.suggestion}`;
+    });
+
+    return { text: lines.join('\n') };
+  }
+}

package/scripts/harness/harness-error/presentation/formatters/human-error-formatter.ts

@@ -0,0 +1,40 @@
+/**
+ * @layer presentation
+ * @unit harness-error
+ *
+ * HarnessErrorContract をヒューマンリーダブルなテキストに変換するフォーマッター
+ */
+import type { HarnessErrorContract } from '../../application/dto/harness-error-contract.js';
+
+export interface HumanErrorFormatterOutput {
+  readonly text: string;
+}
+
+export class HumanErrorFormatter {
+  format(errors: readonly HarnessErrorContract[]): HumanErrorFormatterOutput {
+    if (errors.length === 0) {
+      return { text: 'No errors found.' };
+    }
+
+    const lines: string[] = [];
+
+    for (const error of errors) {
+      const icon = error.severity === 'error' ? 'ERROR' : 'WARN';
+      lines.push(`[${icon}] ${error.code}: ${error.message}`);
+      lines.push(`  Suggestion: ${error.suggestion}`);
+      if (error.adr_ref !== undefined) {
+        lines.push(`  ADR: ${error.adr_ref}`);
+      }
+      if (error.fix_example !== undefined) {
+        lines.push(`  Fix: ${error.fix_example}`);
+      }
+      lines.push('');
+    }
+
+    const errorCount = errors.filter((e) => e.severity === 'error').length;
+    const warningCount = errors.filter((e) => e.severity === 'warning').length;
+    lines.push(`Total: ${errors.length} issue(s) — ${errorCount} error(s), ${warningCount} warning(s)`);
+
+    return { text: lines.join('\n') };
+  }
+}