phasegate 0.15.0

package/scripts/harness/agent-integration/infrastructure/adapters/regex-import-analyzer-adapter.ts

@@ -0,0 +1,69 @@
+/**
+ * @layer infrastructure
+ * @unit agent-integration
+ *
+ * RegexImportAnalyzerAdapter (TsMorphImportAnalyzerAdapter の代替実装)
+ * ts-morph が利用不可のため、正規表現ベースの import 解析を実装する
+ *
+ * 設計注意: ts-morph は package.json に含まれていないため、
+ * node:fs/promises + 正規表現で @anthropic-ai/claude-code の import を検出する
+ */
+
+import * as fs from 'node:fs/promises';
+import type { ImportAnalyzerPort, ImportAnalysisResult } from '../../domain/ports/import-analyzer-port.js';
+
+/** エージェント固有APIのパターン */
+const AGENT_API_PATTERNS = [
+  '@anthropic-ai/claude-code',
+  'claude-code',
+];
+
+/**
+ * TypeScript ファイルから import 文を解析し、
+ * エージェント固有APIの import を検出する
+ */
+function detectAgentImportsInContent(content: string): string[] {
+  const detected: string[] = [];
+  // import { ... } from '...' または import ... from '...' のパターン
+  const importRegex = /import\s+(?:[^'"]*from\s+)?['"]([^'"]+)['"]/g;
+  let match: RegExpExecArray | null;
+
+  while ((match = importRegex.exec(content)) !== null) {
+    const modulePath = match[1];
+    if (modulePath && AGENT_API_PATTERNS.some((pattern) => modulePath === pattern || modulePath.startsWith(`${pattern}/`))) {
+      if (!detected.includes(modulePath)) {
+        detected.push(modulePath);
+      }
+    }
+  }
+
+  return detected;
+}
+
+export class RegexImportAnalyzerAdapter implements ImportAnalyzerPort {
+  async analyzeAgentApiImports(targetFilePaths: string[]): Promise<ImportAnalysisResult[]> {
+    if (targetFilePaths.length === 0) {
+      return [];
+    }
+
+    const results: ImportAnalysisResult[] = [];
+
+    for (const filePath of targetFilePaths) {
+      let content: string;
+      try {
+        content = await fs.readFile(filePath, 'utf8');
+      } catch (error) {
+        // ファイルが存在しない場合はエラーを再スロー
+        throw new Error(`ファイルの読み取りに失敗しました: ${filePath}: ${String(error)}`);
+      }
+
+      const agentApiImports = detectAgentImportsInContent(content);
+      results.push({ filePath, agentApiImports });
+    }
+
+    return results;
+  }
+}
+
+// TsMorphImportAnalyzerAdapter として同じクラスを re-export
+export { RegexImportAnalyzerAdapter as TsMorphImportAnalyzerAdapter };

package/scripts/harness/agent-integration/infrastructure/ports/cli-executor-port.ts

@@ -0,0 +1,29 @@
+/**
+ * @layer infrastructure
+ * @unit agent-integration
+ *
+ * CliExecutorPort — infrastructure層ローカルポート
+ */
+
+export interface CliExecutionResult {
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+  timedOut: boolean;
+}
+
+export class TimeoutError extends Error {
+  constructor(commandName: string, timeoutMs: number) {
+    super(`コマンド実行がタイムアウトしました: ${commandName} (${timeoutMs}ms)`);
+    this.name = 'TimeoutError';
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+export interface CliExecutorPort {
+  execute(
+    command: string,
+    args: string[],
+    timeoutMs?: number
+  ): Promise<CliExecutionResult>;
+}

package/scripts/harness/agent-integration/presentation/post-tool-use-hook.ts

@@ -0,0 +1,104 @@
+/**
+ * @layer presentation
+ * @unit agent-integration
+ *
+ * PostToolUse Hook Adapter
+ * Claude Code の PostToolUse Hook エントリポイント
+ */
+
+import { HandlePostToolUseUseCase } from '../application/usecases/handle-post-tool-use-usecase.js';
+import { HarnessConfigConfigQueryAdapter } from '../infrastructure/adapters/harness-config-config-query-adapter.js';
+import { HarnessApiCliCommandRegistryAdapter } from '../infrastructure/adapters/harness-api-cli-command-registry-adapter.js';
+import { ChildProcessCliExecutorAdapter } from '../infrastructure/adapters/child-process-cli-executor-adapter.js';
+import * as path from 'node:path';
+import * as fs from 'node:fs/promises';
+
+interface PostToolUseHookInput {
+  tool_name?: string;
+  tool_response?: unknown;
+}
+
+async function readStdin(): Promise<string> {
+  const chunks: Buffer[] = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk as Buffer);
+  }
+  return Buffer.concat(chunks).toString('utf8');
+}
+
+async function findConfigPath(): Promise<string> {
+  let dir = process.cwd();
+  while (true) {
+    const candidate = path.join(dir, 'phasegate.config.json');
+    try {
+      await fs.access(candidate);
+      return candidate;
+    } catch {
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  }
+  return path.join(process.cwd(), 'phasegate.config.json');
+}
+
+async function main(): Promise<void> {
+  let raw: string;
+  try {
+    raw = await readStdin();
+  } catch {
+    process.stderr.write('stdin読み取りエラー\n');
+    process.exit(2);
+  }
+
+  let input: PostToolUseHookInput;
+  try {
+    input = JSON.parse(raw) as PostToolUseHookInput;
+  } catch {
+    process.stderr.write(`不正なJSONです: ${raw}\n`);
+    process.exit(2);
+  }
+
+  const toolName = input.tool_name;
+  if (!toolName) {
+    process.stderr.write('tool_nameフィールドが必要です\n');
+    process.exit(2);
+  }
+
+  try {
+    const configPath = await findConfigPath();
+    const configQueryPort = new HarnessConfigConfigQueryAdapter(configPath);
+    const cliCommandRegistryPort = new HarnessApiCliCommandRegistryAdapter();
+    const cliExecutorPort = new ChildProcessCliExecutorAdapter();
+
+    const useCase = new HandlePostToolUseUseCase({
+      configQueryPort,
+      cliExecutorPort,
+      cliCommandRegistryPort,
+    });
+
+    const output = await useCase.execute({ toolName, affectedFilePaths: [] });
+
+    if (output.skipReason) {
+      process.stderr.write(`スキップ: ${output.skipReason}\n`);
+      process.exit(0);
+    }
+
+    if (output.executed && output.cliResult) {
+      if (output.cliResult.exitCode !== 0) {
+        process.stderr.write(`Lint失敗 (exitCode=${output.cliResult.exitCode})\n`);
+      }
+      process.exit(output.cliResult.exitCode);
+    }
+
+    process.exit(0);
+  } catch (error) {
+    process.stderr.write(`実行エラー: ${String(error)}\n`);
+    process.exit(2);
+  }
+}
+
+main().catch((error) => {
+  process.stderr.write(`予期しないエラー: ${String(error)}\n`);
+  process.exit(2);
+});

package/scripts/harness/agent-integration/presentation/pre-tool-use-hook.ts

@@ -0,0 +1,119 @@
+/**
+ * @layer presentation
+ * @unit agent-integration
+ *
+ * PreToolUse Hook Adapter
+ * Claude Code の PreToolUse Hook エントリポイント
+ * stdin からJSON を読み取り、HandlePreToolUseUseCase を呼び出す
+ */
+
+import { HandlePreToolUseUseCase } from '../application/usecases/handle-pre-tool-use-usecase.js';
+import { HarnessConfigConfigQueryAdapter } from '../infrastructure/adapters/harness-config-config-query-adapter.js';
+import { PhaseGateQueryAdapter } from '../infrastructure/adapters/phase-gate-query-adapter.js';
+import * as path from 'node:path';
+import * as fs from 'node:fs/promises';
+
+interface PreToolUseHookInput {
+  cwd?: string;
+  tool_name?: string;
+  tool_input?: {
+    path?: string;
+    file_path?: string;
+    paths?: string[];
+    [key: string]: unknown;
+  };
+}
+
+async function readStdin(): Promise<string> {
+  const chunks: Buffer[] = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk as Buffer);
+  }
+  return Buffer.concat(chunks).toString('utf8');
+}
+
+async function findConfigPath(): Promise<string> {
+  let dir = process.cwd();
+  while (true) {
+    const candidate = path.join(dir, 'phasegate.config.json');
+    try {
+      await fs.access(candidate);
+      return candidate;
+    } catch {
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  }
+  return path.join(process.cwd(), 'phasegate.config.json');
+}
+
+async function main(): Promise<void> {
+  let raw: string;
+  try {
+    raw = await readStdin();
+  } catch {
+    process.stderr.write('stdin読み取りエラー\n');
+    process.exit(2);
+  }
+
+  let input: PreToolUseHookInput;
+  try {
+    input = JSON.parse(raw) as PreToolUseHookInput;
+  } catch {
+    process.stderr.write(`不正なJSONです: ${raw}\n`);
+    process.exit(2);
+  }
+
+  const toolName = input.tool_name;
+  if (!toolName) {
+    process.stderr.write('tool_nameフィールドが必要です\n');
+    process.exit(2);
+  }
+
+  const cwd = input.cwd ?? process.cwd();
+  const toRelative = (p: string): string => {
+    if (path.isAbsolute(p)) {
+      const rel = path.relative(cwd, p);
+      return rel.startsWith('..') ? p : rel;
+    }
+    return p;
+  };
+
+  const targetFilePaths: string[] = [];
+  if (input.tool_input?.file_path) {
+    targetFilePaths.push(toRelative(input.tool_input.file_path));
+  }
+  if (input.tool_input?.path) {
+    targetFilePaths.push(toRelative(input.tool_input.path));
+  }
+  if (input.tool_input?.paths) {
+    targetFilePaths.push(...input.tool_input.paths.map(toRelative));
+  }
+
+  try {
+    const configPath = await findConfigPath();
+    const configQueryPort = new HarnessConfigConfigQueryAdapter(configPath);
+    const phaseGateQueryPort = new PhaseGateQueryAdapter();
+    const useCase = new HandlePreToolUseUseCase({ configQueryPort, phaseGateQueryPort });
+
+    const output = await useCase.execute({ toolName, targetFilePaths });
+
+    if (output.shouldBlock) {
+      const msg = output.error?.message
+        ?? `ファイル保護によりブロックされました: ${output.blockedFilePath ?? '不明なファイル'}`;
+      process.stderr.write(`${msg}\n`);
+      process.exit(2);
+    }
+
+    process.exit(0);
+  } catch (error) {
+    process.stderr.write(`実行エラー: ${String(error)}\n`);
+    process.exit(2);
+  }
+}
+
+main().catch((error) => {
+  process.stderr.write(`予期しないエラー: ${String(error)}\n`);
+  process.exit(2);
+});

package/scripts/harness/agent-integration/presentation/stop-hook.ts

@@ -0,0 +1,106 @@
+/**
+ * @layer presentation
+ * @unit agent-integration
+ *
+ * Stop Hook Adapter
+ * Claude Code の Stop Hook エントリポイント
+ */
+
+import { HandleStopUseCase } from '../application/usecases/handle-stop-usecase.js';
+import { EnvFileReentryGuardStateAdapter } from '../infrastructure/adapters/env-file-reentry-guard-state-adapter.js';
+import { HarnessConfigConfigQueryAdapter } from '../infrastructure/adapters/harness-config-config-query-adapter.js';
+import { HarnessApiCliCommandRegistryAdapter } from '../infrastructure/adapters/harness-api-cli-command-registry-adapter.js';
+import { ChildProcessCliExecutorAdapter } from '../infrastructure/adapters/child-process-cli-executor-adapter.js';
+import * as path from 'node:path';
+import * as fs from 'node:fs/promises';
+
+interface StopHookInput {
+  session_id?: string;
+}
+
+async function readStdin(): Promise<string> {
+  const chunks: Buffer[] = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk as Buffer);
+  }
+  return Buffer.concat(chunks).toString('utf8');
+}
+
+async function findConfigPath(): Promise<string> {
+  let dir = process.cwd();
+  while (true) {
+    const candidate = path.join(dir, 'phasegate.config.json');
+    try {
+      await fs.access(candidate);
+      return candidate;
+    } catch {
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  }
+  return path.join(process.cwd(), 'phasegate.config.json');
+}
+
+async function main(): Promise<void> {
+  let raw: string;
+  try {
+    raw = await readStdin();
+  } catch {
+    process.stderr.write('stdin読み取りエラー\n');
+    process.exit(2);
+  }
+
+  let input: StopHookInput;
+  try {
+    input = JSON.parse(raw) as StopHookInput;
+  } catch {
+    process.stderr.write(`不正なJSONです: ${raw}\n`);
+    process.exit(2);
+  }
+
+  const sessionId = input.session_id;
+  if (!sessionId) {
+    process.stderr.write('session_idフィールドが必要です\n');
+    process.exit(2);
+  }
+
+  try {
+    const configPath = await findConfigPath();
+    const reentryGuardStatePort = new EnvFileReentryGuardStateAdapter({ strategy: 'env' });
+    const configQueryPort = new HarnessConfigConfigQueryAdapter(configPath);
+    const cliCommandRegistryPort = new HarnessApiCliCommandRegistryAdapter();
+    const cliExecutorPort = new ChildProcessCliExecutorAdapter();
+
+    const useCase = new HandleStopUseCase({
+      reentryGuardStatePort,
+      cliExecutorPort,
+      configQueryPort,
+      cliCommandRegistryPort,
+    });
+
+    const output = await useCase.execute({ sessionId });
+
+    if (output.skipReason === 'REENTRY_DETECTED') {
+      process.stderr.write('ReentryGuard: 再入検出によりスキップ\n');
+      process.exit(0);
+    }
+
+    if (output.executed && output.cliResult) {
+      if (output.cliResult.exitCode !== 0) {
+        process.stderr.write(`Complete Check失敗 (exitCode=${output.cliResult.exitCode})\n`);
+      }
+      process.exit(output.cliResult.exitCode);
+    }
+
+    process.exit(0);
+  } catch (error) {
+    process.stderr.write(`実行エラー: ${String(error)}\n`);
+    process.exit(2);
+  }
+}
+
+main().catch((error) => {
+  process.stderr.write(`予期しないエラー: ${String(error)}\n`);
+  process.exit(2);
+});

package/scripts/harness/biome-ast-engine/application/dto/analyze-import-graph-input.ts

@@ -0,0 +1,8 @@
+/**
+ * @layer application
+ * @unit biome-ast-engine
+ */
+
+export type AnalyzeImportGraphInput = {
+  readonly targets?: readonly string[];
+};

package/scripts/harness/biome-ast-engine/application/dto/analyze-import-graph-output.ts

@@ -0,0 +1,14 @@
+/**
+ * @layer application
+ * @unit biome-ast-engine
+ */
+
+import type { FilePath } from '../../domain/value-objects/file-path.js';
+import type { ImportGraph } from '../../domain/value-objects/import-graph.js';
+import type { SourceModuleSnapshot } from '../../domain/value-objects/source-module-snapshot.js';
+
+export type AnalyzeImportGraphOutput = {
+  readonly files: readonly FilePath[];
+  readonly snapshots: readonly SourceModuleSnapshot[];
+  readonly importGraph: ImportGraph;
+};

package/scripts/harness/biome-ast-engine/application/dto/build-harness-error-payload-input.ts

@@ -0,0 +1,10 @@
+/**
+ * @layer application
+ * @unit biome-ast-engine
+ */
+
+import type { RuleViolation } from '../../domain/value-objects/rule-violation.js';
+
+export type BuildHarnessErrorPayloadInput = {
+  readonly violations: readonly RuleViolation[];
+};

package/scripts/harness/biome-ast-engine/application/dto/build-harness-error-payload-output.ts

@@ -0,0 +1,17 @@
+/**
+ * @layer application
+ * @unit biome-ast-engine
+ */
+
+export type HarnessErrorPayloadItem = {
+  readonly code: string;
+  readonly severity: 'error' | 'warning';
+  readonly message: string;
+  readonly suggestion: string;
+  readonly adr_ref?: string;
+  readonly fix_example?: string;
+};
+
+export type BuildHarnessErrorPayloadOutput = {
+  readonly errors: readonly HarnessErrorPayloadItem[];
+};

package/scripts/harness/biome-ast-engine/application/dto/execute-lint-input.ts

@@ -0,0 +1,9 @@
+/**
+ * @layer application
+ * @unit biome-ast-engine
+ */
+
+export type ExecuteLintInput = {
+  readonly targets?: readonly string[];
+  readonly includeBiomeNative?: boolean;
+};

package/scripts/harness/biome-ast-engine/application/dto/execute-lint-output.ts

@@ -0,0 +1,12 @@
+/**
+ * @layer application
+ * @unit biome-ast-engine
+ */
+
+import type { LintReport } from '../../domain/value-objects/lint-report.js';
+import type { FilePath } from '../../domain/value-objects/file-path.js';
+
+export type ExecuteLintOutput = {
+  readonly report: LintReport;
+  readonly checkedFiles: readonly FilePath[];
+};

package/scripts/harness/biome-ast-engine/application/dto/register-rule-catalog-output.ts

@@ -0,0 +1,10 @@
+/**
+ * @layer application
+ * @unit biome-ast-engine
+ */
+
+import type { RuleDefinition } from '../../domain/value-objects/rule-definition.js';
+
+export type RegisterRuleCatalogOutput = {
+  readonly rules: readonly RuleDefinition[];
+};

package/scripts/harness/biome-ast-engine/application/dto/resolve-enabled-rules-input.ts

@@ -0,0 +1,8 @@
+/**
+ * @layer application
+ * @unit biome-ast-engine
+ */
+
+export type ResolveEnabledRulesInput = {
+  readonly overrideRules?: Readonly<Record<string, 'error' | 'warning' | 'off'>>;
+};

package/scripts/harness/biome-ast-engine/application/dto/resolve-enabled-rules-output.ts

@@ -0,0 +1,12 @@
+/**
+ * @layer application
+ * @unit biome-ast-engine
+ */
+
+import type { RuleDefinition } from '../../domain/value-objects/rule-definition.js';
+import type { RuleName } from '../../domain/value-objects/rule-name.js';
+
+export type ResolveEnabledRulesOutput = {
+  readonly enabledRules: readonly RuleDefinition[];
+  readonly skippedRules: readonly RuleName[];
+};

package/scripts/harness/biome-ast-engine/application/dto/verify-eslint-removal-input.ts

@@ -0,0 +1,8 @@
+/**
+ * @layer application
+ * @unit biome-ast-engine
+ */
+
+export type VerifyEslintRemovalInput = {
+  readonly failOnLegacyArtifacts?: boolean;
+};

package/scripts/harness/biome-ast-engine/application/dto/verify-eslint-removal-output.ts

@@ -0,0 +1,10 @@
+/**
+ * @layer application
+ * @unit biome-ast-engine
+ */
+
+export type VerifyEslintRemovalOutput = {
+  readonly configFiles: readonly string[];
+  readonly packageDependencies: readonly string[];
+  readonly hasLegacyArtifacts: boolean;
+};

package/scripts/harness/biome-ast-engine/application/mappers/analyze-import-graph-output-mapper.ts

@@ -0,0 +1,20 @@
+/**
+ * @layer application
+ * @unit biome-ast-engine
+ */
+
+import type { FilePath } from '../../domain/value-objects/file-path.js';
+import type { ImportGraph } from '../../domain/value-objects/import-graph.js';
+import type { SourceModuleSnapshot } from '../../domain/value-objects/source-module-snapshot.js';
+import type { AnalyzeImportGraphOutput } from '../dto/analyze-import-graph-output.js';
+
+export const toAnalyzeImportGraphOutput = (
+  files: readonly FilePath[],
+  snapshots: readonly SourceModuleSnapshot[],
+  importGraph: ImportGraph
+): Readonly<AnalyzeImportGraphOutput> =>
+  Object.freeze({
+    files: Object.freeze([...files]),
+    snapshots: Object.freeze([...snapshots]),
+    importGraph,
+  });

package/scripts/harness/biome-ast-engine/application/mappers/build-harness-error-payload-output-mapper.ts

@@ -0,0 +1,55 @@
+/**
+ * @layer application
+ * @unit biome-ast-engine
+ */
+
+import type { RuleViolation } from '../../domain/value-objects/rule-violation.js';
+import type {
+  BuildHarnessErrorPayloadOutput,
+  HarnessErrorPayloadItem,
+} from '../dto/build-harness-error-payload-output.js';
+
+type FormattedViolation = {
+  readonly code: string;
+  readonly severity: 'error' | 'warning';
+  readonly message: string;
+  readonly suggestion: string;
+  readonly adr_ref?: string;
+  readonly fix_example?: string;
+};
+
+const RULE_CODE_BY_NAME: Readonly<Record<string, string>> = Object.freeze({
+  'require-unit-comment': 'L1-001',
+  'require-layer-comment': 'L1-002',
+  'no-layer-violation': 'L1-003',
+  'enforce-folder-structure': 'L1-004',
+  'no-any-abuse': 'L1-005',
+  'no-ghost-file': 'L1-006',
+  'no-comment-flood': 'L1-007',
+  'no-code-duplication': 'L1-008',
+});
+
+const toHarnessErrorPayloadItem = (
+  violation: RuleViolation,
+  formatted: FormattedViolation
+): Readonly<HarnessErrorPayloadItem> =>
+  Object.freeze({
+    code: RULE_CODE_BY_NAME[violation.ruleName.toString()],
+    severity: formatted.severity,
+    message: formatted.message,
+    suggestion: formatted.suggestion,
+    ...(formatted.adr_ref !== undefined ? { adr_ref: formatted.adr_ref } : {}),
+    ...(formatted.fix_example !== undefined ? { fix_example: formatted.fix_example } : {}),
+  });
+
+export const toBuildHarnessErrorPayloadOutput = (
+  violations: readonly RuleViolation[],
+  formattedErrors: readonly FormattedViolation[]
+): Readonly<BuildHarnessErrorPayloadOutput> =>
+  Object.freeze({
+    errors: Object.freeze(
+      violations.map((violation, index) =>
+        toHarnessErrorPayloadItem(violation, formattedErrors[index]!)
+      )
+    ),
+  });

package/scripts/harness/biome-ast-engine/application/mappers/execute-lint-output-mapper.ts

@@ -0,0 +1,17 @@
+/**
+ * @layer application
+ * @unit biome-ast-engine
+ */
+
+import type { FilePath } from '../../domain/value-objects/file-path.js';
+import type { LintReport } from '../../domain/value-objects/lint-report.js';
+import type { ExecuteLintOutput } from '../dto/execute-lint-output.js';
+
+export const toExecuteLintOutput = (
+  report: LintReport,
+  checkedFiles: readonly FilePath[]
+): Readonly<ExecuteLintOutput> =>
+  Object.freeze({
+    report,
+    checkedFiles: Object.freeze([...checkedFiles]),
+  });

package/scripts/harness/biome-ast-engine/application/mappers/register-rule-catalog-output-mapper.ts

@@ -0,0 +1,14 @@
+/**
+ * @layer application
+ * @unit biome-ast-engine
+ */
+
+import type { RuleDefinition } from '../../domain/value-objects/rule-definition.js';
+import type { RegisterRuleCatalogOutput } from '../dto/register-rule-catalog-output.js';
+
+export const toRegisterRuleCatalogOutput = (
+  rules: readonly RuleDefinition[]
+): Readonly<RegisterRuleCatalogOutput> =>
+  Object.freeze({
+    rules: Object.freeze([...rules]),
+  });