@sk8metal/michi-cli 0.0.9 → 0.1.0

package/dist/scripts/phase-runner.js

@@ -2,13 +2,16 @@
  * フェーズランナー
  * 各フェーズを実行し、Confluence/JIRA作成を確実に実行
  */
-import { existsSync } from 'fs';
-import { join } from 'path';
+import { existsSync, writeFileSync, readFileSync, mkdirSync } from 'fs';
+import { join, relative } from 'path';
 import { syncToConfluence } from './confluence-sync.js';
 import { syncTasksToJIRA } from './jira-sync.js';
 import { validatePhase } from './validate-phase.js';
 import { runPreFlightCheck } from './pre-flight-check.js';
 import { validateFeatureNameOrThrow } from './utils/feature-name-validator.js';
+import { getTestCommands } from './constants/test-commands.js';
+import { loadSpecJson } from './utils/spec-updater.js';
+import inquirer from 'inquirer';
 /**
  * 要件定義フェーズを実行
  */
@@ -28,7 +31,7 @@ async function runRequirementsPhase(feature) {
             confluenceCreated: false,
             jiraCreated: false,
             validationPassed: false,
-            errors
+            errors,
         };
     }
     console.log('✅ requirements.md 存在確認');
@@ -70,7 +73,7 @@ async function runRequirementsPhase(feature) {
         confluenceCreated,
         jiraCreated: false,
         validationPassed: validation.valid,
-        errors
+        errors,
     };
 }
 /**
@@ -92,7 +95,7 @@ async function runDesignPhase(feature) {
             confluenceCreated: false,
             jiraCreated: false,
             validationPassed: false,
-            errors
+            errors,
         };
     }
     console.log('✅ design.md 存在確認');
@@ -134,7 +137,7 @@ async function runDesignPhase(feature) {
         confluenceCreated,
         jiraCreated: false,
         validationPassed: validation.valid,
-        errors
+        errors,
     };
 }
 /**
@@ -150,14 +153,14 @@ async function runTasksPhase(feature) {
     const preFlightResult = await runPreFlightCheck('jira');
     if (!preFlightResult.valid) {
         console.log('\n❌ プリフライトチェック失敗:');
-        preFlightResult.errors.forEach(e => console.log(`  ${e}`));
+        preFlightResult.errors.forEach((e) => console.log(`  ${e}`));
         return {
             phase: 'tasks',
             success: false,
             confluenceCreated: false,
             jiraCreated: false,
             validationPassed: false,
-            errors: preFlightResult.errors
+            errors: preFlightResult.errors,
         };
     }
     console.log('✅ プリフライトチェック成功');
@@ -171,10 +174,92 @@ async function runTasksPhase(feature) {
             confluenceCreated: false,
             jiraCreated: false,
             validationPassed: false,
-            errors
+            errors,
         };
     }
     console.log('✅ tasks.md 存在確認');
+    // Step 1.5: AI-DLC形式検出と変換提案
+    console.log('\n🔍 tasks.mdフォーマット検証中...');
+    const { isAIDLCFormat } = await import('./utils/aidlc-parser.js');
+    const tasksContent = readFileSync(tasksPath, 'utf-8');
+    if (isAIDLCFormat(tasksContent)) {
+        console.log('\n⚠️  AI-DLC形式が検出されました');
+        console.log('   tasks.mdはMichiワークフロー形式ではなくAI-DLC形式です。');
+        console.log('');
+        console.log('🔄 変換オプション:');
+        console.log(`   michi tasks:convert ${feature} --dry-run  # プレビュー`);
+        console.log(`   michi tasks:convert ${feature} --backup   # バックアップ付きで変換`);
+        console.log(`   michi tasks:convert ${feature}            # 直接変換`);
+        console.log('');
+        // 対話的に変換を提案
+        const shouldConvert = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'convert',
+                message: 'AI-DLC形式をMichiワークフロー形式に変換しますか？',
+                default: true,
+            },
+        ]);
+        if (shouldConvert.convert) {
+            console.log('\n🔄 AI-DLC形式をMichiワークフロー形式に変換中...');
+            const { convertTasksFile } = await import('./utils/tasks-converter.js');
+            const result = convertTasksFile(tasksPath, undefined, {
+                backup: true,
+                language: 'ja',
+                projectName: feature,
+            });
+            if (result.success) {
+                console.log('✅ 変換成功！');
+                console.log(`   元ファイル: ${result.backupPath}`);
+                console.log(`   変換後: ${tasksPath}`);
+                console.log(`   統計: ${result.stats.originalTasks}タスク → ${result.stats.convertedStories}ストーリー`);
+            }
+            else {
+                errors.push('AI-DLC形式の変換に失敗しました');
+                result.warnings.forEach((w) => errors.push(w));
+                console.error('❌ 変換失敗');
+                return {
+                    phase: 'tasks',
+                    success: false,
+                    confluenceCreated: false,
+                    jiraCreated: false,
+                    validationPassed: false,
+                    errors,
+                };
+            }
+        }
+        else {
+            console.log('\n⏭️  変換をスキップしました');
+            console.log('   AI-DLC形式のままではJIRA連携が正常に動作しない可能性があります。');
+            errors.push('tasks.mdがAI-DLC形式のため、フォーマット検証をスキップしました');
+            return {
+                phase: 'tasks',
+                success: false,
+                confluenceCreated: false,
+                jiraCreated: false,
+                validationPassed: false,
+                errors,
+            };
+        }
+    }
+    // Step 1.6: tasks.mdフォーマット検証
+    const { validateTasksFormat } = await import('./utils/tasks-format-validator.js');
+    try {
+        validateTasksFormat(tasksPath);
+        console.log('✅ tasks.mdフォーマット検証成功');
+    }
+    catch (error) {
+        errors.push(`フォーマット検証失敗: ${error.message}`);
+        console.error('❌ フォーマット検証失敗:', error.message);
+        return {
+            phase: 'tasks',
+            success: false,
+            confluenceCreated: false,
+            jiraCreated: false,
+            validationPassed: false,
+            errors,
+        };
+    }
     // Step 2: JIRA Epic/Story作成
     console.log('\n📤 JIRA Epic/Story作成中...');
     try {
@@ -207,7 +292,689 @@ async function runTasksPhase(feature) {
         confluenceCreated: false,
         jiraCreated,
         validationPassed: validation.valid,
-        errors
+        errors,
+    };
+}
+/**
+ * テストタイプ選択フェーズを実行（Phase 0.3）
+ * 対話的にテストタイプを選択
+ */
+async function runTestTypeSelectionPhase(feature) {
+    console.log('\n🧪 Phase 0.3: Test Type Selection（テストタイプ選択）');
+    console.log('='.repeat(60));
+    const errors = [];
+    const specDir = join(process.cwd(), '.kiro', 'specs', feature);
+    const selectionPath = join(specDir, 'test-type-selection.json');
+    // 既存の選択を読み込む（存在する場合）
+    let existingSelection = null;
+    if (existsSync(selectionPath)) {
+        try {
+            existingSelection = JSON.parse(readFileSync(selectionPath, 'utf-8'));
+            console.log('\n📋 既存の選択が見つかりました:');
+            console.log(`   選択済みテストタイプ: ${existingSelection.selectedTypes?.join(', ') || 'なし'}`);
+        }
+        catch {
+            console.warn('⚠️  既存の選択ファイルの読み込みに失敗しました');
+        }
+    }
+    console.log('\n📚 プロジェクト要件に応じてテストタイプを選択してください\n');
+    // 対話的な質問
+    const answers = await inquirer.prompt([
+        {
+            type: 'checkbox',
+            name: 'testTypes',
+            message: '実施するテストタイプを選択してください（スペースキーで選択/解除、Enterで確定）:',
+            choices: [
+                {
+                    name: '単体テスト (Unit Tests) - 必須 [Phase A]',
+                    value: 'unit',
+                    checked: true, // 必須のためデフォルトで選択
+                    disabled: true, // 必須のため変更不可
+                },
+                {
+                    name: 'Lint実行 - 必須 [Phase A]',
+                    value: 'lint',
+                    checked: true,
+                    disabled: true,
+                },
+                {
+                    name: 'ビルド実行 - 必須 [Phase A]',
+                    value: 'build',
+                    checked: true,
+                    disabled: true,
+                },
+                new inquirer.Separator('--- 推奨テスト ---'),
+                {
+                    name: '統合テスト (Integration Tests) - 推奨 [Phase 3/B]',
+                    value: 'integration',
+                    checked: existingSelection?.selectedTypes?.includes('integration') || false,
+                },
+                {
+                    name: 'E2Eテスト (End-to-End Tests) - 推奨 [Phase 3/B]',
+                    value: 'e2e',
+                    checked: existingSelection?.selectedTypes?.includes('e2e') || false,
+                },
+                new inquirer.Separator('--- 任意テスト ---'),
+                {
+                    name: '性能テスト (Performance Tests) - 任意 [Phase B]',
+                    value: 'performance',
+                    checked: existingSelection?.selectedTypes?.includes('performance') || false,
+                },
+                {
+                    name: 'セキュリティテスト (Security Tests) - 任意 [Phase B]',
+                    value: 'security',
+                    checked: existingSelection?.selectedTypes?.includes('security') || false,
+                },
+            ],
+            validate: () => {
+                // disabled項目は自動的に含まれるため、バリデーションは常に成功
+                return true;
+            },
+        },
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: (answers) => {
+                // 必須テストを自動的に追加
+                const required = ['unit', 'lint', 'build'];
+                const selected = [...new Set([...required, ...answers.testTypes])];
+                const optional = selected.filter((t) => !required.includes(t));
+                if (optional.length === 0) {
+                    return '必須テストのみが選択されています。この選択で進めますか？';
+                }
+                return `選択したテストタイプ: ${selected.join(', ')}\nこの選択で進めますか？`;
+            },
+            default: true,
+        },
+    ]);
+    // 必須テストを自動的に追加（disabled項目はanswers.testTypesに含まれないため）
+    const requiredTests = ['unit', 'lint', 'build'];
+    answers.testTypes = [...new Set([...requiredTests, ...answers.testTypes])];
+    if (!answers.confirm) {
+        console.log('\n❌ 選択がキャンセルされました');
+        return {
+            phase: 'test-type-selection',
+            success: false,
+            confluenceCreated: false,
+            jiraCreated: false,
+            validationPassed: false,
+            errors: ['ユーザーが選択をキャンセルしました'],
+        };
+    }
+    // 選択結果を保存
+    const selection = {
+        feature,
+        selectedTypes: answers.testTypes,
+        selectedAt: new Date().toISOString(),
+        testTypes: {
+            unit: {
+                enabled: true,
+                required: true,
+                phase: 'A',
+                description: '単体テスト',
+            },
+            lint: {
+                enabled: true,
+                required: true,
+                phase: 'A',
+                description: 'Lint実行',
+            },
+            build: {
+                enabled: true,
+                required: true,
+                phase: 'A',
+                description: 'ビルド実行',
+            },
+            integration: {
+                enabled: answers.testTypes.includes('integration'),
+                required: false,
+                phase: 'B',
+                description: '統合テスト',
+            },
+            e2e: {
+                enabled: answers.testTypes.includes('e2e'),
+                required: false,
+                phase: 'B',
+                description: 'E2Eテスト',
+            },
+            performance: {
+                enabled: answers.testTypes.includes('performance'),
+                required: false,
+                phase: 'B',
+                description: '性能テスト',
+            },
+            security: {
+                enabled: answers.testTypes.includes('security'),
+                required: false,
+                phase: 'B',
+                description: 'セキュリティテスト',
+            },
+        },
+    };
+    // ディレクトリが存在しない場合は作成
+    if (!existsSync(specDir)) {
+        mkdirSync(specDir, { recursive: true });
+    }
+    // 選択結果を保存
+    writeFileSync(selectionPath, JSON.stringify(selection, null, 2), 'utf-8');
+    console.log(`\n✅ テストタイプ選択を保存しました: ${selectionPath}`);
+    // spec.jsonを更新
+    try {
+        const specPath = join(specDir, 'spec.json');
+        if (existsSync(specPath)) {
+            const spec = JSON.parse(readFileSync(specPath, 'utf-8'));
+            spec.testTypeSelection = {
+                completed: true,
+                selectedTypes: answers.testTypes,
+                selectedAt: selection.selectedAt,
+            };
+            spec.lastUpdated = new Date().toISOString();
+            writeFileSync(specPath, JSON.stringify(spec, null, 2), 'utf-8');
+            console.log('✅ spec.jsonを更新しました');
+        }
+    }
+    catch (error) {
+        errors.push(`spec.json更新失敗: ${error.message}`);
+        console.warn(`⚠️  spec.json更新失敗: ${error.message}`);
+    }
+    // 選択結果のサマリーを表示
+    console.log('\n' + '='.repeat(60));
+    console.log('📊 選択結果サマリー:');
+    console.log(`   必須テスト: ${['unit', 'lint', 'build'].join(', ')}`);
+    const optional = answers.testTypes.filter((t) => !['unit', 'lint', 'build'].includes(t));
+    if (optional.length > 0) {
+        console.log(`   追加テスト: ${optional.join(', ')}`);
+    }
+    else {
+        console.log('   追加テスト: なし');
+    }
+    console.log('\n📖 次のステップ:');
+    console.log('   1. Phase 0.4: テスト仕様書作成へ進む');
+    console.log('      michi phase:run ' + feature + ' test-spec');
+    console.log('   2. 詳細ガイド: docs/user-guide/testing/test-planning-flow.md');
+    console.log('\n' + '='.repeat(60));
+    console.log('✅ Phase 0.3: テストタイプ選択が完了しました');
+    return {
+        phase: 'test-type-selection',
+        success: true,
+        confluenceCreated: false,
+        jiraCreated: false,
+        validationPassed: true,
+        errors,
+    };
+}
+/**
+ * テスト仕様書作成フェーズを実行（Phase 0.4）
+ * 自動生成: test-type-selectionから選択されたテストタイプの仕様書を生成
+ */
+async function runTestSpecPhase(feature) {
+    console.log('\n📝 Phase 0.4: Test Specification（テスト仕様書作成）');
+    console.log('='.repeat(60));
+    const errors = [];
+    // Step 1: テストタイプ選択の読み込み
+    const selectionPath = join(process.cwd(), '.kiro', 'specs', feature, 'test-type-selection.json');
+    if (!existsSync(selectionPath)) {
+        errors.push('test-type-selection.jsonが存在しません。先にtest-type-selectionフェーズを実行してください');
+        return {
+            phase: 'test-spec',
+            success: false,
+            confluenceCreated: false,
+            jiraCreated: false,
+            validationPassed: false,
+            errors,
+        };
+    }
+    let selection;
+    let testTypes = [];
+    try {
+        selection = JSON.parse(readFileSync(selectionPath, 'utf-8'));
+        testTypes = selection.selectedTypes || [];
+    }
+    catch (error) {
+        errors.push(`test-type-selection.jsonの読み込みまたはパースに失敗しました: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            phase: 'test-spec',
+            success: false,
+            confluenceCreated: false,
+            jiraCreated: false,
+            validationPassed: false,
+            errors,
+        };
+    }
+    console.log(`\n✅ 選択されたテストタイプ: ${testTypes.join(', ')}`);
+    // Step 2: 各テストタイプのテスト仕様書を生成
+    console.log('\n🤖 テスト仕様書を自動生成中...');
+    const specDir = join(process.cwd(), '.kiro', 'specs', feature, 'test-specs');
+    mkdirSync(specDir, { recursive: true });
+    const { generateTestSpec } = await import('./test-spec-generator.js');
+    const generatedSpecs = [];
+    for (const testType of testTypes) {
+        // lint/buildはテスト仕様書不要（CI設定で対応）
+        if (testType === 'lint' || testType === 'build') {
+            console.log(`   ⏭️  ${testType}: スキップ（CI設定で対応）`);
+            continue;
+        }
+        try {
+            await generateTestSpec(feature, testType);
+            console.log(`   ✅ ${testType}テスト仕様書: ${testType}-test-spec.md`);
+            generatedSpecs.push(testType);
+        }
+        catch (error) {
+            errors.push(`${testType}テスト仕様書生成失敗: ${error.message}`);
+            console.error(`   ❌ ${testType}テスト仕様書生成失敗: ${error.message}`);
+        }
+    }
+    // Step 3: spec.json更新
+    const specPath = join(process.cwd(), '.kiro', 'specs', feature, 'spec.json');
+    if (existsSync(specPath)) {
+        try {
+            const spec = JSON.parse(readFileSync(specPath, 'utf-8'));
+            spec.testSpecification = {
+                completed: true,
+                generatedAt: new Date().toISOString(),
+                testTypes: testTypes,
+                generatedSpecs: generatedSpecs,
+            };
+            spec.lastUpdated = new Date().toISOString();
+            writeFileSync(specPath, JSON.stringify(spec, null, 2), 'utf-8');
+            console.log('\n✅ spec.jsonを更新しました');
+        }
+        catch (error) {
+            errors.push(`spec.json更新失敗: ${error.message}`);
+            console.warn(`⚠️  spec.json更新失敗: ${error.message}`);
+        }
+    }
+    // Step 4: サマリー表示
+    console.log('\n' + '='.repeat(60));
+    console.log('📊 テスト仕様書作成完了:');
+    console.log(`   生成されたファイル: ${generatedSpecs.length}件`);
+    console.log(`   保存先: .kiro/specs/${feature}/test-specs/`);
+    if (generatedSpecs.length > 0) {
+        console.log('\n📄 生成されたファイル:');
+        generatedSpecs.forEach((type) => {
+            console.log(`   - ${type}-test-spec.md`);
+        });
+    }
+    console.log('\n📖 次のステップ:');
+    console.log('   1. Phase 0.5: タスク分割へ進む');
+    console.log(`      michi phase:run ${feature} tasks`);
+    console.log('\n' + '='.repeat(60));
+    console.log('✅ Phase 0.4: テスト仕様書作成が完了しました');
+    return {
+        phase: 'test-spec',
+        success: errors.length === 0 && generatedSpecs.length > 0,
+        confluenceCreated: false,
+        jiraCreated: false,
+        validationPassed: true,
+        errors,
+    };
+}
+/**
+ * 環境構築フェーズを実行（Phase 1）
+ * 対話的に環境を構築し、必要な設定ファイルを生成
+ */
+async function runEnvironmentSetupPhase(feature) {
+    console.log('\n⚙️  Phase 1: Environment Setup（環境構築）');
+    console.log('='.repeat(60));
+    const errors = [];
+    // Step 1: プロジェクト検出
+    const { detectProject } = await import('./utils/project-detector.js');
+    const detected = detectProject();
+    console.log(`\n🔍 検出されたプロジェクト: ${detected.language}`);
+    console.log(`   ビルドツール: ${detected.buildTool}`);
+    if (detected.testFramework) {
+        console.log(`   テストフレームワーク: ${detected.testFramework}`);
+    }
+    if (detected.hasCI) {
+        console.log('   CI/CD: 既存の設定あり');
+    }
+    // Step 2: 実装言語を分析
+    const { analyzeLanguage } = await import('./utils/language-detector.js');
+    const languageAnalysis = analyzeLanguage(feature);
+    if (languageAnalysis.confidence !== 'low') {
+        console.log(`\n💡 実装言語を推奨します: ${languageAnalysis.language}（信頼度: ${languageAnalysis.confidence}）`);
+        console.log('   理由:');
+        languageAnalysis.reasons.forEach((reason) => console.log(`   - ${reason}`));
+    }
+    // Step 3: Docker Compose要件を分析
+    const { analyzeDockerRequirement } = await import('./utils/docker-requirement-detector.js');
+    const dockerAnalysis = analyzeDockerRequirement(feature);
+    if (dockerAnalysis.recommended) {
+        console.log(`\n💡 Docker Composeを推奨します（信頼度: ${dockerAnalysis.confidence}）`);
+        console.log('   理由:');
+        dockerAnalysis.reasons.forEach((reason) => console.log(`   - ${reason}`));
+        if (dockerAnalysis.suggestedServices.length > 0) {
+            console.log(`   推奨サービス: ${dockerAnalysis.suggestedServices.join(', ')}`);
+        }
+    }
+    // Step 4: 対話的質問
+    console.log('\n📚 環境構築を対話的に設定します\n');
+    const languageMap = {
+        nodejs: 'Node.js/TypeScript',
+        java: 'Java',
+        php: 'PHP',
+        python: 'Python',
+        go: 'Go',
+        rust: 'Rust',
+        other: 'その他',
+    };
+    // 言語のデフォルト値を決定（分析結果 > プロジェクト検出）
+    const defaultLanguage = languageAnalysis.confidence !== 'low'
+        ? languageAnalysis.language
+        : languageMap[detected.language] || 'その他';
+    const answers = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'language',
+            message: languageAnalysis.confidence !== 'low'
+                ? `プロジェクトの言語を選択してください（推奨: ${languageAnalysis.language}）:`
+                : 'プロジェクトの言語を選択してください:',
+            choices: [
+                'Node.js/TypeScript',
+                'Java',
+                'PHP',
+                'Python',
+                'Go',
+                'Rust',
+                'その他',
+            ],
+            default: defaultLanguage,
+        },
+        {
+            type: 'list',
+            name: 'ciTool',
+            message: 'CI/CDツールを選択してください:',
+            choices: ['GitHub Actions', 'Screwdriver', 'GitLab CI', 'なし'],
+            default: detected.hasCI ? 'GitHub Actions' : 'GitHub Actions',
+        },
+        {
+            type: 'confirm',
+            name: 'needsDocker',
+            message: dockerAnalysis.recommended
+                ? `Docker Composeを使用しますか？（推奨: ${dockerAnalysis.confidence}）`
+                : 'Docker Composeが必要ですか？（データベース・モックサーバー用）',
+            default: dockerAnalysis.recommended,
+        },
+        {
+            type: 'confirm',
+            name: 'installDeps',
+            message: '依存関係を自動インストールしますか？',
+            default: true,
+            when: () => detected.hasDependencies,
+        },
+    ]);
+    // Docker Composeの推奨サービスを保存
+    answers.suggestedServices = dockerAnalysis.suggestedServices;
+    // Step 3: 設定ファイル生成
+    console.log('\n🤖 設定ファイルを生成中...');
+    try {
+        const { generateCIConfig } = await import('./utils/ci-generator.js');
+        await generateCIConfig(feature, answers);
+    }
+    catch (error) {
+        errors.push(`CI/CD設定生成失敗: ${error.message}`);
+        console.error(`   ❌ CI/CD設定生成失敗: ${error.message}`);
+    }
+    try {
+        const { generateTestConfig } = await import('./utils/test-config-generator.js');
+        await generateTestConfig(feature, answers);
+    }
+    catch (error) {
+        errors.push(`テスト設定生成失敗: ${error.message}`);
+        console.error(`   ❌ テスト設定生成失敗: ${error.message}`);
+    }
+    if (answers.needsDocker) {
+        try {
+            const { generateDockerCompose } = await import('./utils/docker-generator.js');
+            await generateDockerCompose(feature, answers.suggestedServices || []);
+        }
+        catch (error) {
+            errors.push(`Docker Compose生成失敗: ${error.message}`);
+            console.error(`   ❌ Docker Compose生成失敗: ${error.message}`);
+        }
+    }
+    // Step 4: 依存関係インストール（オプション）
+    if (answers.installDeps) {
+        console.log('\n📦 依存関係をインストール中...');
+        const { execSync } = await import('child_process');
+        // 言語別のビルドファイル存在確認
+        const buildFileChecks = {
+            'Node.js/TypeScript': 'package.json',
+            Java: 'build.gradle',
+            PHP: 'composer.json',
+            Python: 'requirements.txt',
+            Go: 'go.mod',
+            Rust: 'Cargo.toml',
+        };
+        const buildFile = buildFileChecks[answers.language];
+        if (!buildFile || !existsSync(buildFile)) {
+            console.log(`   ℹ️  ${buildFile || 'ビルドファイル'}が見つかりません（スキップ）`);
+            console.log('   💡 実際のプロジェクトでは、先にプロジェクトを初期化してください');
+        }
+        else {
+            const commands = {
+                'Node.js/TypeScript': detected.packageManager === 'pnpm'
+                    ? 'pnpm install'
+                    : detected.packageManager === 'yarn'
+                        ? 'yarn install'
+                        : 'npm install',
+                Java: existsSync('./gradlew')
+                    ? './gradlew build --no-daemon'
+                    : 'gradle build',
+                PHP: 'composer install',
+                Python: 'pip install -r requirements.txt',
+                Go: 'go mod download',
+                Rust: 'cargo fetch',
+            };
+            const command = commands[answers.language];
+            if (command) {
+                try {
+                    execSync(command, { stdio: 'inherit', cwd: process.cwd() });
+                    console.log('   ✅ 依存関係のインストール完了');
+                }
+                catch (error) {
+                    console.warn(`   ⚠️  依存関係インストール失敗: ${error.message}`);
+                    console.warn('   💡 プロジェクト初期化後に手動でインストールしてください');
+                }
+            }
+        }
+    }
+    // Step 5: spec.json更新
+    const specPath = join(process.cwd(), '.kiro', 'specs', feature, 'spec.json');
+    if (existsSync(specPath)) {
+        try {
+            const spec = JSON.parse(readFileSync(specPath, 'utf-8'));
+            spec.environmentSetup = {
+                completed: true,
+                language: answers.language,
+                ciTool: answers.ciTool,
+                dockerCompose: answers.needsDocker,
+                completedAt: new Date().toISOString(),
+            };
+            spec.lastUpdated = new Date().toISOString();
+            writeFileSync(specPath, JSON.stringify(spec, null, 2), 'utf-8');
+            console.log('\n✅ spec.jsonを更新しました');
+        }
+        catch (error) {
+            errors.push(`spec.json更新失敗: ${error.message}`);
+            console.warn(`⚠️  spec.json更新失敗: ${error.message}`);
+        }
+    }
+    // Step 6: サマリー表示
+    console.log('\n' + '='.repeat(60));
+    console.log('📊 環境構築完了:');
+    console.log(`   言語: ${answers.language}`);
+    console.log(`   CI/CD: ${answers.ciTool}`);
+    console.log(`   Docker Compose: ${answers.needsDocker ? 'あり' : 'なし'}`);
+    console.log('\n📖 次のステップ:');
+    console.log('   1. Phase 2: TDD実装へ進む');
+    console.log(`      /kiro:spec-impl ${feature}`);
+    console.log('\n' + '='.repeat(60));
+    console.log('✅ Phase 1: 環境構築が完了しました');
+    return {
+        phase: 'environment-setup',
+        success: errors.length === 0,
+        confluenceCreated: false,
+        jiraCreated: false,
+        validationPassed: true,
+        errors,
+    };
+}
+/**
+ * PR前自動テストフェーズを実行（Phase A）
+ * マニュアル対応：CI/CD案内を表示
+ */
+async function runPhaseAPhase(feature) {
+    console.log('\n🤖 Phase A: PR前自動テスト（PR Tests）');
+    console.log('='.repeat(60));
+    const errors = [];
+    // spec.jsonから言語を読み取る
+    const spec = loadSpecJson(feature);
+    const language = spec.environmentSetup?.language || 'Node.js/TypeScript';
+    const commands = getTestCommands(language);
+    console.log('\n📚 このフェーズはCI/CD自動実行です');
+    console.log('PR作成時に以下のテストが自動実行されます:\n');
+    console.log('自動実行テスト:');
+    console.log(`  - 単体テスト (${commands.test})`);
+    console.log(`  - Lint実行 (${commands.lint})`);
+    console.log(`  - ビルド実行 (${commands.build})\n`);
+    console.log('CI/CD設定ファイル:');
+    console.log('  - .github/workflows/ci.yml');
+    console.log('  - .github/workflows/test.yml\n');
+    console.log('📖 詳細ガイド:');
+    console.log('  docs/user-guide/testing/test-execution-flow.md\n');
+    console.log('確認事項:');
+    console.log('  [ ] CI/CDパイプラインが正常に動作している');
+    console.log('  [ ] すべての自動テストが成功している');
+    console.log('  [ ] テストカバレッジが95%以上');
+    console.log('\n' + '='.repeat(60));
+    console.log('✅ Phase A: PR前自動テスト案内を表示しました');
+    console.log('📢 CI/CDが自動実行します。Phase 3に進んでください');
+    return {
+        phase: 'phase-a',
+        success: true,
+        confluenceCreated: false,
+        jiraCreated: false,
+        validationPassed: true,
+        errors,
+    };
+}
+/**
+ * リリース準備テストフェーズを実行（Phase B）
+ * テスト実行ファイルを自動生成し、手動テストチェックリストを表示
+ */
+async function runPhaseBPhase(feature) {
+    console.log('\n🔍 Phase B: リリース準備テスト（Release Tests）');
+    console.log('='.repeat(60));
+    const errors = [];
+    const generatedFiles = [];
+    // Step 1: テストタイプ選択の読み込み
+    const selectionPath = join(process.cwd(), '.kiro', 'specs', feature, 'test-type-selection.json');
+    let selectedTypes = [];
+    if (existsSync(selectionPath)) {
+        try {
+            const selection = JSON.parse(readFileSync(selectionPath, 'utf-8'));
+            selectedTypes = selection.selectedTypes || [];
+            console.log(`\n✅ 選択されたテストタイプ: ${selectedTypes.join(', ')}`);
+        }
+        catch {
+            console.warn('⚠️  test-type-selection.jsonの読み込みに失敗しました');
+        }
+    }
+    else {
+        console.log('\n⚠️  test-type-selection.jsonが存在しません');
+        console.log('   デフォルトのテストタイプを使用します');
+        selectedTypes = [
+            'unit',
+            'lint',
+            'build',
+            'integration',
+            'performance',
+            'security',
+        ];
+    }
+    // Step 2: Phase B対象のテストタイプを抽出
+    const phaseBTypes = selectedTypes.filter((t) => !['unit', 'lint', 'build'].includes(t));
+    if (phaseBTypes.length > 0) {
+        console.log(`\n📝 Phase B対象テスト: ${phaseBTypes.join(', ')}`);
+        // Step 3: テスト実行ファイルを生成
+        console.log('\n🤖 テスト実行ファイルを自動生成中...');
+        const { generateTestExecution } = await import('./test-execution-generator.js');
+        for (const testType of phaseBTypes) {
+            try {
+                const result = await generateTestExecution(feature, testType);
+                if (result.success) {
+                    console.log(`   ✅ ${result.testType}: ${result.files.length}ファイル生成`);
+                    generatedFiles.push(...result.files);
+                }
+                else {
+                    console.error(`   ❌ ${result.testType}: ${result.error}`);
+                    errors.push(`${result.testType}テスト生成失敗: ${result.error}`);
+                }
+            }
+            catch (error) {
+                errors.push(`${testType}テスト生成失敗: ${error.message}`);
+                console.error(`❌ ${testType}テスト生成失敗:`, error.message);
+            }
+        }
+    }
+    // Step 4: 生成されたファイルのサマリー
+    const testExecutionDir = join(process.cwd(), '.kiro', 'specs', feature, 'test-execution');
+    if (generatedFiles.length > 0) {
+        console.log('\n📄 生成されたファイル:');
+        generatedFiles.forEach((file) => {
+            const relativePath = relative(testExecutionDir, file);
+            console.log(`   - ${relativePath}`);
+        });
+    }
+    // Step 5: チェックリスト表示
+    console.log('\n' + '='.repeat(60));
+    console.log('📋 リリース準備テストチェックリスト:\n');
+    if (phaseBTypes.includes('performance')) {
+        console.log('  [ ] 性能テスト実行');
+        console.log(`      📁 .kiro/specs/${feature}/test-execution/performance/`);
+        console.log('      📖 詳細はディレクトリ内のREADME/計画書を参照');
+    }
+    if (phaseBTypes.includes('security')) {
+        console.log('  [ ] セキュリティテスト実行');
+        console.log(`      📁 .kiro/specs/${feature}/test-execution/security/`);
+        console.log('      📖 詳細はディレクトリ内のREADME/計画書を参照');
+    }
+    if (phaseBTypes.includes('integration')) {
+        console.log('  [ ] 統合テスト実行');
+        console.log(`      📁 .kiro/specs/${feature}/test-execution/integration/`);
+    }
+    if (phaseBTypes.includes('e2e')) {
+        console.log('  [ ] E2Eテスト実行');
+        console.log(`      📁 .kiro/specs/${feature}/test-execution/e2e/`);
+    }
+    console.log('\n参考ドキュメント:');
+    console.log(`  - .kiro/specs/${feature}/test-specs/ (テスト仕様書)`);
+    console.log('  - docs/user-guide/testing/test-execution-flow.md');
+    console.log('\n次のステップ:');
+    console.log('  1. 生成されたテストファイルを確認・編集');
+    console.log('  2. 各テストを実行');
+    console.log('  3. テスト結果をドキュメント化');
+    console.log('  4. Phase 4: リリース準備へ進む');
+    console.log('\n' + '='.repeat(60));
+    const success = errors.length === 0;
+    if (success) {
+        console.log('✅ Phase B: テスト実行ファイル生成が完了しました');
+        console.log('📢 テストを実行してPhase 4に進んでください');
+    }
+    else {
+        console.log('⚠️  Phase B: テスト実行ファイル生成が部分的に完了しました');
+        console.log(`❌ ${errors.length}件のエラーが発生しています`);
+        errors.forEach((err) => console.log(`   - ${err}`));
+        console.log('📢 エラーを修正してから再実行してください');
+    }
+    return {
+        phase: 'phase-b',
+        success,
+        confluenceCreated: false,
+        jiraCreated: false,
+        validationPassed: true,
+        errors,
     };
 }
 /**
@@ -221,8 +988,18 @@ export async function runPhase(feature, phase) {
             return await runRequirementsPhase(feature);
         case 'design':
             return await runDesignPhase(feature);
+        case 'test-type-selection':
+            return await runTestTypeSelectionPhase(feature);
+        case 'test-spec':
+            return await runTestSpecPhase(feature);
         case 'tasks':
             return await runTasksPhase(feature);
+        case 'environment-setup':
+            return await runEnvironmentSetupPhase(feature);
+        case 'phase-a':
+            return await runPhaseAPhase(feature);
+        case 'phase-b':
+            return await runPhaseBPhase(feature);
         default:
             throw new Error(`Unknown phase: ${phase}`);
     }
@@ -233,12 +1010,31 @@ if (import.meta.url === `file://${process.argv[1]}`) {
     if (args.length < 2) {
         console.error('Usage: npm run phase:run <feature> <phase>');
         console.error('Example: npm run phase:run calculator-app requirements');
-        console.error('Phases: requirements, design, tasks');
+        console.error('\nAvailable Phases:');
+        console.error('  requirements       - Phase 0.1: 要件定義');
+        console.error('  design             - Phase 0.2: 設計');
+        console.error('  test-type-selection- Phase 0.3: テストタイプ選択（任意）');
+        console.error('  test-spec          - Phase 0.4: テスト仕様書作成（任意）');
+        console.error('  tasks              - Phase 0.5-0.6: タスク分割・JIRA同期');
+        console.error('  environment-setup  - Phase 1: 環境構築（任意）');
+        console.error('  phase-a            - Phase A: PR前自動テスト（任意）');
+        console.error('  phase-b            - Phase B: リリース準備テスト（任意）');
         process.exit(1);
     }
     const [feature, phase] = args;
-    if (!['requirements', 'design', 'tasks'].includes(phase)) {
-        console.error('Invalid phase. Must be: requirements, design, or tasks');
+    const validPhases = [
+        'requirements',
+        'design',
+        'test-type-selection',
+        'test-spec',
+        'tasks',
+        'environment-setup',
+        'phase-a',
+        'phase-b',
+    ];
+    if (!validPhases.includes(phase)) {
+        console.error(`Invalid phase: ${phase}`);
+        console.error('Must be one of: requirements, design, test-type-selection, test-spec, tasks, environment-setup, phase-a, phase-b');
         process.exit(1);
     }
     runPhase(feature, phase)