phasegate 0.15.0

package/scripts/harness/config-foundation/infrastructure/schemas/harness-config-v2.schema.json

@@ -0,0 +1,254 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "project",
+    "layers",
+    "quickMode",
+    "phaseDependencies",
+    "planningMode",
+    "harnesses",
+    "paths",
+    "reporting"
+  ],
+  "properties": {
+    "project": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["name", "preset"],
+      "properties": {
+        "name": {
+          "type": "string",
+          "minLength": 1
+        },
+        "preset": {
+          "type": "string",
+          "enum": ["minimal", "standard", "strict"]
+        }
+      }
+    },
+    "layers": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "L0": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "enabled": {
+              "type": "boolean"
+            },
+            "validators": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              },
+              "uniqueItems": true
+            }
+          }
+        },
+        "L1": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "enabled": {
+              "type": "boolean"
+            },
+            "rules": {
+              "type": "object",
+              "additionalProperties": {
+                "type": "string"
+              }
+            }
+          }
+        },
+        "L2": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "enabled": {
+              "type": "boolean"
+            },
+            "validators": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              },
+              "uniqueItems": true
+            }
+          }
+        },
+        "L3": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "enabled": {
+              "type": "boolean"
+            },
+            "validators": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              },
+              "uniqueItems": true
+            },
+            "coverageThreshold": {
+              "type": "number",
+              "minimum": 0,
+              "maximum": 100
+            }
+          }
+        },
+        "L4": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "enabled": {
+              "type": "boolean"
+            },
+            "validators": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              },
+              "uniqueItems": true
+            },
+            "schedule": {
+              "type": "string",
+              "minLength": 1
+            }
+          }
+        }
+      }
+    },
+    "quickMode": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "allowedCategories": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "uniqueItems": true
+        },
+        "maintainedLayers": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "uniqueItems": true
+        },
+        "relaxedGates": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "uniqueItems": true
+        }
+      }
+    },
+    "phaseDependencies": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["preset", "override", "customRules"],
+      "properties": {
+        "preset": {
+          "type": "string",
+          "enum": ["default", "custom"]
+        },
+        "override": {
+          "type": "boolean"
+        },
+        "customRules": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["phase", "requires"],
+            "properties": {
+              "phase": {
+                "type": "string",
+                "minLength": 1
+              },
+              "requires": {
+                "type": "array",
+                "items": {
+                  "type": "string"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "planningMode": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["default", "perPhase"],
+      "properties": {
+        "default": {
+          "type": "string",
+          "enum": ["interactive", "embedded-qa"]
+        },
+        "perPhase": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "string",
+            "enum": ["interactive", "embedded-qa"]
+          }
+        }
+      }
+    },
+    "harnesses": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "agentLessonCollection": {
+          "type": "boolean"
+        },
+        "cascadeUpdate": {
+          "type": "boolean"
+        },
+        "bundleSizeLimit": {
+          "type": "number",
+          "minimum": 0
+        },
+        "deadCodeGC": {
+          "type": "boolean"
+        }
+      }
+    },
+    "paths": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["designDocs", "inceptionDocs"],
+      "properties": {
+        "designDocs": {
+          "type": "string",
+          "minLength": 1
+        },
+        "inceptionDocs": {
+          "type": "string",
+          "minLength": 1
+        }
+      }
+    },
+    "reporting": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["format", "outputDir"],
+      "properties": {
+        "format": {
+          "type": "string",
+          "minLength": 1
+        },
+        "outputDir": {
+          "type": "string",
+          "minLength": 1
+        }
+      }
+    }
+  }
+}

package/scripts/harness/config-foundation/infrastructure/validators/ajv-config-schema-validator.ts

@@ -0,0 +1,114 @@
+/**
+ * @layer infrastructure
+ * @unit config-foundation
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import Ajv, { type ErrorObject, type ValidateFunction } from 'ajv';
+import { HarnessError } from '../../../harness-error/domain/value-objects/harness-error.js';
+import { ErrorCode } from '../../../harness-error/domain/value-objects/error-code.js';
+import { Severity } from '../../../harness-error/domain/value-objects/severity.js';
+import type { ConfigSchemaValidatorPort } from '../../domain/ports/config-schema-validator-port.js';
+
+type HarnessErrorWithPath = HarnessError & {
+  readonly errorCode: string;
+  readonly path: string;
+};
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const SCHEMA_PATH = path.resolve(__dirname, '../schemas/harness-config-v2.schema.json');
+
+function loadSchema(): object {
+  const raw = fs.readFileSync(SCHEMA_PATH, 'utf8');
+  return JSON.parse(raw) as object;
+}
+
+function createValidateFunction(): ValidateFunction {
+  const ajv = new Ajv({
+    allErrors: true,
+  });
+
+  return ajv.compile(loadSchema());
+}
+
+function buildPath(error: ErrorObject): string {
+  const errorParams = error.params as Record<string, unknown>;
+  // ajv v8 では instancePath が JSON Pointer 形式（v6 の dataPath に相当）
+  const instancePath = error.instancePath ?? '';
+
+  if (error.keyword === 'required') {
+    const missingProperty = String(errorParams.missingProperty ?? '');
+    return `${instancePath}/${missingProperty}` || '/';
+  }
+
+  if (error.keyword === 'additionalProperties') {
+    const additionalProperty = String(errorParams.additionalProperty ?? '');
+    return `${instancePath}/${additionalProperty}` || '/';
+  }
+
+  return instancePath || '/';
+}
+
+function buildErrorCode(error: ErrorObject, actualPath: string): string {
+  if (error.keyword === 'enum' && actualPath === '/project/preset') {
+    return 'L1-002';
+  }
+
+  if (error.keyword === 'minimum' && actualPath === '/harnesses/bundleSizeLimit') {
+    return 'L1-003';
+  }
+
+  return 'L1-001';
+}
+
+function buildMessage(error: ErrorObject, actualPath: string): string {
+  const errorParams = error.params as Record<string, unknown>;
+
+  switch (error.keyword) {
+    case 'required':
+      return `required: ${actualPath} is required`;
+    case 'minimum':
+      return `minimum: ${actualPath} must be >= ${String(errorParams.limit)}`;
+    case 'enum':
+      return `enum: ${actualPath} must be one of ${String(
+        (errorParams.allowedValues as readonly unknown[] | undefined)?.join(', ') ?? '',
+      )}`;
+    case 'additionalProperties':
+      return `additionalProperties: ${actualPath} is not allowed`;
+    default:
+      return `${error.keyword}: ${actualPath} ${error.message ?? 'is invalid'}`;
+  }
+}
+
+function toHarnessError(error: ErrorObject): HarnessErrorWithPath {
+  const actualPath = buildPath(error);
+  const errorCode = buildErrorCode(error, actualPath);
+  const harnessError = new HarnessError({
+    code: ErrorCode.create(errorCode),
+    severity: Severity.create('error'),
+    message: buildMessage(error, actualPath),
+    suggestion: '設定ファイルを修正してください',
+    adrRef: null,
+    fixExample: null,
+  }) as HarnessErrorWithPath;
+
+  return Object.assign(harnessError, {
+    errorCode,
+    path: actualPath,
+  });
+}
+
+const validateSchema = createValidateFunction();
+
+export class AjvConfigSchemaValidator implements ConfigSchemaValidatorPort {
+  validate(document: unknown): readonly HarnessError[] {
+    const valid = validateSchema(document);
+
+    if (valid) {
+      return [];
+    }
+
+    return (validateSchema.errors ?? []).map((error) => toHarnessError(error));
+  }
+}

package/scripts/harness/config-foundation/presentation/cli/disable-feature-command-handler.ts

@@ -0,0 +1,93 @@
+/**
+ * @layer presentation
+ * @unit config-foundation
+ *
+ * feature disable コマンドのハンドラー
+ * --list 指定時は利用可能機能一覧を表示し、それ以外は機能を無効化する
+ */
+import type { FeatureToggleResult } from '../../application/dto/feature-toggle-result.js';
+import type { AvailableFeatureItem } from '../../application/dto/available-feature-item.js';
+
+export interface DisableFeatureCommandInput {
+  readonly featureName?: string;
+  readonly list: boolean;
+  readonly configPath?: string;
+}
+
+export interface DisableFeatureCommandOutput {
+  readonly exitCode: number;
+  readonly output: string;
+}
+
+export interface DisableFeaturePort {
+  execute(featureName: string, configPath?: string): Promise<FeatureToggleResult>;
+}
+
+export interface ListAvailableFeaturesForDisablePort {
+  execute(configPath?: string): Promise<readonly AvailableFeatureItem[]>;
+}
+
+export interface DisableFeatureCommandHandlerDeps {
+  readonly disableFeatureUseCase: DisableFeaturePort;
+  readonly listAvailableFeaturesUseCase: ListAvailableFeaturesForDisablePort;
+}
+
+export class DisableFeatureCommandHandler {
+  private readonly disableFeatureUseCase: DisableFeaturePort;
+  private readonly listAvailableFeaturesUseCase: ListAvailableFeaturesForDisablePort;
+
+  constructor(deps: DisableFeatureCommandHandlerDeps) {
+    this.disableFeatureUseCase = deps.disableFeatureUseCase;
+    this.listAvailableFeaturesUseCase = deps.listAvailableFeaturesUseCase;
+  }
+
+  async execute(
+    input: DisableFeatureCommandInput,
+  ): Promise<DisableFeatureCommandOutput> {
+    try {
+      if (input.list) {
+        return await this.executeList(input.configPath);
+      }
+
+      if (input.featureName === undefined) {
+        return {
+          exitCode: 2,
+          output: 'Error: feature name is required. Use --list to see available features.',
+        };
+      }
+
+      return await this.executeDisable(input.featureName, input.configPath);
+    } catch (error: unknown) {
+      const message =
+        error instanceof Error ? error.message : 'Unknown error occurred';
+      return { exitCode: 2, output: `Error: ${message}` };
+    }
+  }
+
+  private async executeList(
+    configPath?: string,
+  ): Promise<DisableFeatureCommandOutput> {
+    const features =
+      await this.listAvailableFeaturesUseCase.execute(configPath);
+    const lines: string[] = ['Available features:'];
+    for (const feature of features) {
+      const status = feature.enabled ? '[enabled]' : '[disabled]';
+      lines.push(`  ${feature.name} ${status}`);
+    }
+    return { exitCode: 0, output: lines.join('\n') };
+  }
+
+  private async executeDisable(
+    featureName: string,
+    configPath?: string,
+  ): Promise<DisableFeatureCommandOutput> {
+    const result = await this.disableFeatureUseCase.execute(
+      featureName,
+      configPath,
+    );
+    return {
+      exitCode: 0,
+      output: `Feature "${result.feature}" disabled in ${result.configPath}`,
+    };
+  }
+}

package/scripts/harness/config-foundation/presentation/cli/enable-feature-command-handler.ts

@@ -0,0 +1,93 @@
+/**
+ * @layer presentation
+ * @unit config-foundation
+ *
+ * feature enable コマンドのハンドラー
+ * --list 指定時は利用可能機能一覧を表示し、それ以外は機能を有効化する
+ */
+import type { FeatureToggleResult } from '../../application/dto/feature-toggle-result.js';
+import type { AvailableFeatureItem } from '../../application/dto/available-feature-item.js';
+
+export interface EnableFeatureCommandInput {
+  readonly featureName?: string;
+  readonly list: boolean;
+  readonly configPath?: string;
+}
+
+export interface EnableFeatureCommandOutput {
+  readonly exitCode: number;
+  readonly output: string;
+}
+
+export interface EnableFeaturePort {
+  execute(featureName: string, configPath?: string): Promise<FeatureToggleResult>;
+}
+
+export interface ListAvailableFeaturesPort {
+  execute(configPath?: string): Promise<readonly AvailableFeatureItem[]>;
+}
+
+export interface EnableFeatureCommandHandlerDeps {
+  readonly enableFeatureUseCase: EnableFeaturePort;
+  readonly listAvailableFeaturesUseCase: ListAvailableFeaturesPort;
+}
+
+export class EnableFeatureCommandHandler {
+  private readonly enableFeatureUseCase: EnableFeaturePort;
+  private readonly listAvailableFeaturesUseCase: ListAvailableFeaturesPort;
+
+  constructor(deps: EnableFeatureCommandHandlerDeps) {
+    this.enableFeatureUseCase = deps.enableFeatureUseCase;
+    this.listAvailableFeaturesUseCase = deps.listAvailableFeaturesUseCase;
+  }
+
+  async execute(
+    input: EnableFeatureCommandInput,
+  ): Promise<EnableFeatureCommandOutput> {
+    try {
+      if (input.list) {
+        return await this.executeList(input.configPath);
+      }
+
+      if (input.featureName === undefined) {
+        return {
+          exitCode: 2,
+          output: 'Error: feature name is required. Use --list to see available features.',
+        };
+      }
+
+      return await this.executeEnable(input.featureName, input.configPath);
+    } catch (error: unknown) {
+      const message =
+        error instanceof Error ? error.message : 'Unknown error occurred';
+      return { exitCode: 2, output: `Error: ${message}` };
+    }
+  }
+
+  private async executeList(
+    configPath?: string,
+  ): Promise<EnableFeatureCommandOutput> {
+    const features =
+      await this.listAvailableFeaturesUseCase.execute(configPath);
+    const lines: string[] = ['Available features:'];
+    for (const feature of features) {
+      const status = feature.enabled ? '[enabled]' : '[disabled]';
+      lines.push(`  ${feature.name} ${status}`);
+    }
+    return { exitCode: 0, output: lines.join('\n') };
+  }
+
+  private async executeEnable(
+    featureName: string,
+    configPath?: string,
+  ): Promise<EnableFeatureCommandOutput> {
+    const result = await this.enableFeatureUseCase.execute(
+      featureName,
+      configPath,
+    );
+    return {
+      exitCode: 0,
+      output: `Feature "${result.feature}" enabled in ${result.configPath}`,
+    };
+  }
+}

package/scripts/harness/harness-api/application/dto/command-dispatch-input.ts

@@ -0,0 +1,7 @@
+// command-dispatch-input.ts — CommandDispatchInput DTO
+
+export interface CommandDispatchInput {
+  commandName: string;
+  args: Record<string, string>;
+  flags: Record<string, boolean | string>;
+}

package/scripts/harness/harness-api/application/dto/command-dispatch-output.ts

@@ -0,0 +1,9 @@
+// command-dispatch-output.ts — CommandDispatchOutput DTO
+
+import type { ExitCode } from '../../domain/value-objects/harness-api-response.js';
+import type { HarnessApiResponseContract } from './harness-api-response-contract.js';
+
+export interface CommandDispatchOutput<T = unknown> {
+  response: Readonly<HarnessApiResponseContract<T>>;
+  exitCode: ExitCode;
+}

package/scripts/harness/harness-api/application/dto/exit-code-decision-input.ts

@@ -0,0 +1,8 @@
+// exit-code-decision-input.ts — ExitCodeDecisionInput DTO
+
+import type { ResponseStatus } from '../../domain/value-objects/harness-api-response.js';
+
+export interface ExitCodeDecisionInput {
+  status: ResponseStatus;
+  commandName: string;
+}

package/scripts/harness/harness-api/application/dto/exit-code-decision-output.ts

@@ -0,0 +1,8 @@
+// exit-code-decision-output.ts — ExitCodeDecisionOutput DTO
+
+import type { ExitCode } from '../../domain/value-objects/harness-api-response.js';
+
+export interface ExitCodeDecisionOutput {
+  exitCode: ExitCode;
+  reason: string;
+}

package/scripts/harness/harness-api/application/dto/harness-api-response-contract.ts

@@ -0,0 +1,10 @@
+// harness-api-response-contract.ts — Cross-Unit Contract DTO
+
+import type { ResponseStatus, HarnessError, ResponseSummary } from '../../domain/value-objects/harness-api-response.js';
+
+export interface HarnessApiResponseContract<T = unknown> {
+  readonly status: ResponseStatus;
+  readonly errors: readonly HarnessError[];
+  readonly summary: ResponseSummary | string;
+  readonly data: T | undefined;
+}

package/scripts/harness/harness-api/application/dto/initialize-registry-input.ts

@@ -0,0 +1,11 @@
+// initialize-registry-input.ts — InitializeRegistryInput DTO
+
+export interface CliCommandDefinitionInput {
+  commandName: string;
+  description?: string;
+  handler?: unknown;
+}
+
+export interface InitializeRegistryInput {
+  commands: readonly CliCommandDefinitionInput[];
+}

package/scripts/harness/harness-api/application/dto/registry-summary-output.ts

@@ -0,0 +1,9 @@
+// registry-summary-output.ts — RegistrySummaryOutput DTO
+
+import type { CommandName } from '../../domain/value-objects/cli-command-definition.js';
+
+export interface RegistrySummaryOutput {
+  registeredCount: number;
+  commandNames: readonly CommandName[];
+  failedRegistrations: readonly { commandName: string; reason: string }[];
+}

package/scripts/harness/harness-api/application/dto/status-derivation-input.ts

@@ -0,0 +1,6 @@
+// status-derivation-input.ts — StatusDerivationInput DTO
+
+// Currently no parameters — extensible for future filter conditions
+export interface StatusDerivationInput {
+  [key: string]: unknown;
+}

package/scripts/harness/harness-api/application/mappers/harness-api-response-mapper.ts

@@ -0,0 +1,16 @@
+// harness-api-response-mapper.ts — HarnessApiResponseMapper
+
+import type { HarnessApiResponse } from '../../domain/value-objects/harness-api-response.js';
+import type { HarnessApiResponseContract } from '../dto/harness-api-response-contract.js';
+
+export class HarnessApiResponseMapper {
+  toContract<T>(response: HarnessApiResponse<T>): Readonly<HarnessApiResponseContract<T>> {
+    const contract: HarnessApiResponseContract<T> = {
+      status: response.status,
+      errors: response.errors,
+      summary: response.summary,
+      data: response.data,
+    };
+    return Object.freeze(contract);
+  }
+}

package/scripts/harness/harness-api/application/usecases/decide-exit-code-usecase.ts

@@ -0,0 +1,27 @@
+// decide-exit-code-usecase.ts — DecideExitCodeUseCase
+
+import type { ExitCodeDecisionInput } from '../dto/exit-code-decision-input.js';
+import type { ExitCodeDecisionOutput } from '../dto/exit-code-decision-output.js';
+import type { ExitCode } from '../../domain/value-objects/harness-api-response.js';
+
+export class DecideExitCodeUseCase {
+  execute(input: ExitCodeDecisionInput): ExitCodeDecisionOutput {
+    const { status, commandName } = input;
+
+    // D5ルール: harness:status は fail でも exitCode=0 を返す
+    if (commandName === 'harness:status' && status === 'fail') {
+      return {
+        exitCode: 0 as ExitCode,
+        reason: 'D5ルール適用: harness:statusコマンドはfailでもexitCode=0を返す（情報提供コマンドのため）',
+      };
+    }
+
+    if (status === 'pass') {
+      return { exitCode: 0 as ExitCode, reason: 'status=passのため exitCode=0' };
+    }
+    if (status === 'fail') {
+      return { exitCode: 1 as ExitCode, reason: 'status=failのため exitCode=1' };
+    }
+    return { exitCode: 2 as ExitCode, reason: 'status=errorのため exitCode=2' };
+  }
+}