ai-git-tools 2.0.60 → 2.0.62

package/bin/cli.js

@@ -142,7 +142,7 @@ program
   .command('write-and-test')
   .description('AI 為指定檔案生成 Jest 測試，並自動執行與修復（最多 2 次）')
   .requiredOption('--file <path>', '原始碼路徑')
-  .option('--test-type <type>', '測試類型：auto、unit 或 component（預設 auto）', 'auto')
+  .option('--test-type <type>', '測試類型：auto、unit、component 或 both（可用逗號指定多個）', 'auto')
   .option('--max-fixes <number>', '最大自動修復次數（預設 2）', '2')
   .option('--no-confirm', '跳過確認直接生成並執行測試')
   .option('--model <model>', '指定 AI 模型')
@@ -158,11 +158,11 @@ program
 // Auto Dev 整合命令
 program
   .command('auto-dev')
-  .description('一鍵自動化：從 GitHub Issue 到代碼生成、測試與提交')
+  .description('一鍵自動化：從 GitHub Issue 到代碼生成與測試修正')
   .requiredOption('--issue <number>', 'GitHub Issue 編號')
   .option('--file <path>', '目標檔案路徑（若無則自動推斷）')
   .option('--context <description>', '額外說明或補充需求')
-  .option('--test-type <type>', '測試類型：auto、unit 或 component（預設 auto）', 'auto')
+  .option('--test-type <type>', '測試類型：auto、unit、component 或 both（預設 auto）', 'auto')
   .option('--max-lines <number>', '最大行數限制（預設 500）', '500')
   .option('--max-fixes <number>', '最大自動修復次數（預設 2）', '2')
   .option('--no-confirm', '全自動模式，跳過所有確認')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-git-tools",
-  "version": "2.0.60",
+  "version": "2.0.62",
   "description": "AI-powered Git automation tools for commit messages and PR generation",
   "main": "src/index.js",
   "type": "module",

package/src/commands/auto-dev.js

@@ -11,8 +11,7 @@ import inquirer from 'inquirer';
 import { IssueReader } from '../core/issue-reader.js';
 import { CodeGenerator } from '../core/code-generator.js';
 import { AIClient } from '../core/ai-client.js';
-import { GitOperations } from '../core/git-operations.js';
-import { writeAndTestCommand } from './write-and-test.js';
+import { writeAndTestCommand, TEST_TYPE_CHOICES, normalizeTestTypeSelection, resolveRequestedTestTypes } from './write-and-test.js';
 import { Logger } from '../utils/logger.js';
 
 export async function autoDevCommand(options = {}) {
@@ -107,7 +106,7 @@ export async function autoDevCommand(options = {}) {
   try {
     codeResult = await CodeGenerator.generateFile(issue, absoluteFilePath, {
       maxLines: parseInt(options.maxLines || '500', 10),
-      language: filePath.endsWith('.ts') ? 'ts' : 'js',
+      language: getLanguageFromFilePath(filePath),
       extraContext: options.context || '',
       model: options.model,
     });
@@ -119,8 +118,15 @@ export async function autoDevCommand(options = {}) {
 
   console.log('');
 
+  const selectedTestType = await resolveTestTypeForAutoDev({
+    noConfirm,
+    requestedTestType: options.testType,
+  });
+
+  const resolvedRuntimeTestTypes = resolveRequestedTestTypes(absoluteFilePath, selectedTestType);
+
   logger.step('正在驗證專案可用的測試腳本...');
-  ensureJestAvailable();
+  ensureJestAvailable(resolvedRuntimeTestTypes);
   logger.success('已確認可執行 Jest 測試。');
   console.log('');
 
@@ -129,7 +135,7 @@ export async function autoDevCommand(options = {}) {
   // ============================================================
   const testResult = await writeAndTestCommand({
     file: filePath,
-    testType: options.testType || 'auto',
+    testType: selectedTestType,
     maxFixes: options.maxFixes || '2',
     model: options.model,
     noConfirm: true,
@@ -141,25 +147,15 @@ export async function autoDevCommand(options = {}) {
     return;
   }
 
-  // ============================================================
-  // 第七步：自動 Commit
-  // ============================================================
-  logger.step('正在自動提交...');
-  try {
-    GitOperations.exec(`git add "${absoluteFilePath}" "${testResult.testFilePath}"`, { silent: true });
-    const commitMsg = `feat(auto-dev): Issue #${issue.number} - ${issue.title}\n\n生成檔案：\n- ${filePath}\n- ${testResult.testFilePath.replace(process.cwd(), '.')}`;
-    GitOperations.exec(`git commit -m "${commitMsg.split('\n')[0]}"`, { silent: true });
-    logger.success('已自動提交');
-  } catch {
-    logger.warning('自動 commit 失敗（可能已有相同 commit 或尚未 staged）');
-  }
-
   console.log('');
   logger.section('✅ 自動化工作流完成');
   console.log(`Issue #${issue.number}：${issue.title}`);
   console.log(`生成檔案：${filePath}`);
-  console.log(`測試檔案：${testResult.testFilePath.replace(process.cwd(), '.')}`);
-  console.log(`測試類型：${testResult.testType}`);
+  testResult.testFilePaths.forEach((testFilePath) => {
+    console.log(`測試檔案：${testFilePath.replace(process.cwd(), '.')}`);
+  });
+  console.log(`測試類型：${testResult.testTypes.join('、')}`);
+  console.log('狀態：已完成代碼與測試流程，未自動 commit');
   console.log(`合計行數：${codeResult.linesCount + ' (程式碼)'}`);
 }
 
@@ -244,26 +240,40 @@ function isValidTargetPath(value) {
     && !value.startsWith('/');
 }
 
-function ensureJestAvailable() {
+function getLanguageFromFilePath(filePath) {
+  return /\.(ts|tsx)$/.test(filePath) ? 'ts' : 'js';
+}
+
+async function resolveTestTypeForAutoDev({ noConfirm, requestedTestType }) {
+  const defaultTestType = normalizeTestTypeSelection(requestedTestType || 'auto')[0] || 'auto';
+
+  if (noConfirm) {
+    return requestedTestType || 'auto';
+  }
+
+  const { testType } = await inquirer.prompt([{
+    type: 'list',
+    name: 'testType',
+    message: '請選擇這次要執行的測試方式：',
+    choices: TEST_TYPE_CHOICES,
+    default: defaultTestType === 'auto' ? 'both' : defaultTestType,
+  }]);
+
+  return testType;
+}
+
+function ensureJestAvailable(runtimeTestType = ['unit']) {
+  const packageJson = readProjectPackageJson();
+
   try {
     execSync('npx jest --version', {
       encoding: 'utf-8',
       stdio: 'pipe',
       cwd: process.cwd(),
     });
+    ensureComponentTestDependencies(packageJson, runtimeTestType);
+    return;
   } catch {
-    const packageJsonPath = resolve(process.cwd(), 'package.json');
-    if (!existsSync(packageJsonPath)) {
-      throw new Error('目前目錄沒有 package.json，無法執行 Jest 測試。');
-    }
-
-    let packageJson;
-    try {
-      packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-    } catch {
-      throw new Error('無法讀取目前專案的 package.json，請確認 Jest 已安裝。');
-    }
-
     const hasJestDependency = Boolean(
       packageJson.dependencies?.jest || packageJson.devDependencies?.jest
     );
@@ -272,6 +282,40 @@ function ensureJestAvailable() {
       throw new Error('目前專案未安裝 Jest，請先安裝後再執行 auto-dev。');
     }
 
+    ensureComponentTestDependencies(packageJson, runtimeTestType);
+
     throw new Error('偵測到 Jest 依賴，但無法執行 npx jest，請檢查安裝或 lockfile 狀態。');
   }
 }
+
+function readProjectPackageJson() {
+  const packageJsonPath = resolve(process.cwd(), 'package.json');
+  if (!existsSync(packageJsonPath)) {
+    throw new Error('目前目錄沒有 package.json，無法執行 Jest 測試。');
+  }
+
+  try {
+    return JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+  } catch {
+    throw new Error('無法讀取目前專案的 package.json，請確認 Jest 已安裝。');
+  }
+}
+
+function ensureComponentTestDependencies(packageJson, runtimeTestType) {
+  if (!runtimeTestType.includes('component')) {
+    return;
+  }
+
+  const hasJsdomDependency = Boolean(
+    packageJson.devDependencies?.['jest-environment-jsdom']
+    || packageJson.dependencies?.['jest-environment-jsdom']
+  );
+  const hasTestingLibraryDependency = Boolean(
+    packageJson.devDependencies?.['@testing-library/react']
+    || packageJson.dependencies?.['@testing-library/react']
+  );
+
+  if (!hasJsdomDependency || !hasTestingLibraryDependency) {
+    throw new Error('元件測試需要 jest-environment-jsdom 與 @testing-library/react，請先安裝後再執行 auto-dev。');
+  }
+}

package/src/commands/generate-code.js

@@ -8,6 +8,7 @@ import { resolve } from 'path';
 import inquirer from 'inquirer';
 import { IssueReader } from '../core/issue-reader.js';
 import { CodeGenerator } from '../core/code-generator.js';
+import { writeAndTestCommand, TEST_TYPE_CHOICES, normalizeTestTypeSelection } from './write-and-test.js';
 import { Logger } from '../utils/logger.js';
 
 export async function generateCodeCommand(options = {}) {
@@ -61,7 +62,7 @@ export async function generateCodeCommand(options = {}) {
 
   const result = await CodeGenerator.generateFile(issue, absolutePath, {
     maxLines,
-    language: absolutePath.endsWith('.ts') ? 'ts' : 'js',
+    language: /\.(ts|tsx)$/.test(absolutePath) ? 'ts' : 'js',
     extraContext,
     model: options.model,
   });
@@ -84,5 +85,31 @@ export async function generateCodeCommand(options = {}) {
   console.log('\n💡 下一步：執行 write-and-test 為此檔案生成並執行測試');
   console.log(`   ai-git-tools write-and-test --file ${filePath}`);
 
+  if (!options.noConfirm) {
+    const { nextAction } = await inquirer.prompt([{
+      type: 'list',
+      name: 'nextAction',
+      message: '代碼已生成，接下來要如何處理測試？',
+      choices: [
+        ...TEST_TYPE_CHOICES,
+        {
+          name: '先不執行測試',
+          value: 'skip',
+        },
+      ],
+      default: 'both',
+    }]);
+
+    if (nextAction !== 'skip') {
+      await writeAndTestCommand({
+        file: filePath,
+        testType: normalizeTestTypeSelection(nextAction).join(','),
+        maxFixes: options.maxFixes || '2',
+        model: options.model,
+        noConfirm: true,
+      });
+    }
+  }
+
   return result;
 }

package/src/commands/write-and-test.js

@@ -4,18 +4,94 @@
  */
 
 import { resolve, basename, dirname, join } from 'path';
-import { existsSync } from 'fs';
-import { execSync } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
 import inquirer from 'inquirer';
 import { TestGenerator } from '../core/test-generator.js';
 import { TestRunner } from '../core/test-runner.js';
 import { Logger } from '../utils/logger.js';
 
+export const TEST_TYPE_CHOICES = [
+  {
+    name: '寫測試（自動判斷 Jest 單元測試 / 元件測試）',
+    value: 'auto',
+  },
+  {
+    name: '寫 Jest 單元測試',
+    value: 'unit',
+  },
+  {
+    name: '寫元件測試',
+    value: 'component',
+  },
+  {
+    name: '同時寫 Jest 單元測試 + 元件測試',
+    value: 'both',
+  },
+];
+
+export function normalizeTestTypeSelection(testType = 'auto') {
+  const rawValues = Array.isArray(testType)
+    ? testType
+    : String(testType)
+      .split(',')
+      .map((value) => value.trim())
+      .filter(Boolean);
+
+  const normalizedValues = rawValues.length > 0 ? rawValues : ['auto'];
+  const resolvedValues = normalizedValues.flatMap((value) => {
+    const normalized = value.toLowerCase();
+
+    if (normalized === 'auto' || normalized === 'unit' || normalized === 'component') {
+      return normalized;
+    }
+
+    if (normalized === 'both' || normalized === 'all') {
+      return ['unit', 'component'];
+    }
+
+    if (normalized === 'jest' || normalized === 'jest-unit' || normalized === 'unit-test') {
+      return 'unit';
+    }
+
+    if (normalized === 'component-test' || normalized === 'react-component') {
+      return 'component';
+    }
+
+    throw new Error(`不支援的測試類型：${value}`);
+  });
+
+  return [...new Set(resolvedValues)];
+}
+
+export function resolveRequestedTestTypes(sourceFilePath, requestedTestType = 'auto') {
+  const normalizedTestTypes = normalizeTestTypeSelection(requestedTestType);
+
+  if (!normalizedTestTypes.includes('auto')) {
+    return normalizedTestTypes;
+  }
+
+  const sourceCode = readFileSync(sourceFilePath, 'utf-8');
+  const inferredTestType = TestGenerator.resolveTestType(sourceFilePath, sourceCode, 'auto');
+
+  return [...new Set(
+    normalizedTestTypes.flatMap((testType) => (testType === 'auto' ? inferredTestType : testType))
+  )];
+}
+
+function formatTestTypes(testTypes) {
+  const labels = {
+    auto: '自動判斷',
+    unit: 'Jest 單元測試',
+    component: '元件測試',
+  };
+
+  return testTypes.map((testType) => labels[testType] || testType).join('、');
+}
+
 export async function writeAndTestCommand(options = {}) {
   const logger = new Logger();
 
   const filePath = options.file;
-  const requestedTestType = options.testType || 'auto';
   const maxFixes = parseInt(options.maxFixes || '2', 10);
 
   if (!filePath) {
@@ -29,13 +105,18 @@ export async function writeAndTestCommand(options = {}) {
     throw new Error(`找不到原始碼：${absoluteSourcePath}`);
   }
 
-  // 推導測試檔案路徑
-  const testFilePath = deriveTestFilePath(absoluteSourcePath);
+  const resolvedTestTypes = resolveRequestedTestTypes(absoluteSourcePath, options.testType || 'auto');
+  const testTargets = resolvedTestTypes.map((testType) => ({
+    testType,
+    testFilePath: deriveTestFilePath(absoluteSourcePath, testType),
+  }));
 
   logger.header('write-and-test');
   console.log(`原始碼  ：${absoluteSourcePath}`);
-  console.log(`測試檔案：${testFilePath}`);
-  console.log(`測試類型：${requestedTestType}`);
+  console.log(`測試類型：${formatTestTypes(resolvedTestTypes)}`);
+  testTargets.forEach(({ testType, testFilePath }) => {
+    console.log(`${testType === 'component' ? '元件測試' : '單元測試'}：${testFilePath}`);
+  });
   console.log(`最大修復：${maxFixes} 次`);
   console.log('');
 
@@ -44,7 +125,7 @@ export async function writeAndTestCommand(options = {}) {
     const { confirmed } = await inquirer.prompt([{
       type: 'confirm',
       name: 'confirmed',
-      message: `確認為 ${filePath} 生成 ${requestedTestType} 測試並執行？`,
+      message: `確認為 ${filePath} 生成 ${formatTestTypes(resolvedTestTypes)} 並執行？`,
       default: true,
     }]);
 
@@ -56,14 +137,18 @@ export async function writeAndTestCommand(options = {}) {
 
   // 2. 生成測試
   logger.step('正在生成測試代碼...');
-  const generatedTest = await TestGenerator.generateTests(
-    absoluteSourcePath,
-    testFilePath,
-    requestedTestType,
-    options.model
-  );
-  logger.success(`測試已寫入：${testFilePath}`);
-  logger.info(`實際測試類型：${generatedTest.testType}`);
+  const generatedTests = [];
+  for (const { testType, testFilePath } of testTargets) {
+    const generatedTest = await TestGenerator.generateTests(
+      absoluteSourcePath,
+      testFilePath,
+      testType,
+      options.model
+    );
+    generatedTests.push(generatedTest);
+    logger.success(`測試已寫入：${testFilePath}`);
+  }
+  logger.info(`實際測試類型：${formatTestTypes(generatedTests.map(({ testType }) => testType))}`);
 
   // 3. 執行測試 + 自動修復循環
   let lastErrors = [];
@@ -75,16 +160,15 @@ export async function writeAndTestCommand(options = {}) {
     }
 
     logger.step(`正在執行測試${attempt > 0 ? `（第 ${attempt} 次修復後）` : ''}...`);
-    const result = await TestRunner.runTests(testFilePath);
+    const result = await TestRunner.runTests(generatedTests.map(({ testFilePath }) => testFilePath));
 
     if (result.success) {
       logger.success('所有測試通過！ 🎉');
-
-      // 4. 自動 commit 測試檔案
-      if (!options.skipCommit) {
-        await commitGeneratedFiles(testFilePath, absoluteSourcePath, logger);
-      }
-      return { success: true, testFilePath, testType: generatedTest.testType };
+      return {
+        success: true,
+        testFilePaths: generatedTests.map(({ testFilePath }) => testFilePath),
+        testTypes: generatedTests.map(({ testType }) => testType),
+      };
     }
 
     lastErrors = result.errors;
@@ -106,12 +190,14 @@ export async function writeAndTestCommand(options = {}) {
       });
       console.log('');
       console.log(`原始碼路徑：${absoluteSourcePath}`);
-      console.log(`測試路徑  ：${testFilePath}`);
+      generatedTests.forEach(({ testFilePath }) => {
+        console.log(`測試路徑  ：${testFilePath}`);
+      });
       return {
         success: false,
-        testFilePath,
+        testFilePaths: generatedTests.map(({ testFilePath }) => testFilePath),
         errors: lastErrors,
-        testType: generatedTest.testType,
+        testTypes: generatedTests.map(({ testType }) => testType),
       };
     }
   }
@@ -119,25 +205,11 @@ export async function writeAndTestCommand(options = {}) {
 
 /**
  * 依據原始檔案路徑推導測試檔案路徑
- * e.g. src/core/foo.js → src/core/__tests__/foo.test.js
  */
-function deriveTestFilePath(sourceFilePath) {
+export function deriveTestFilePath(sourceFilePath, testType = 'unit') {
   const dir = dirname(sourceFilePath);
-  const name = basename(sourceFilePath).replace(/\.(js|ts|mjs|cjs)$/, '');
-  const ext = sourceFilePath.endsWith('.ts') ? '.ts' : '.js';
-  return join(dir, '__tests__', `${name}.test${ext}`);
-}
-
-/**
- * 將原始碼與測試檔案一併 commit 到 git
- */
-async function commitGeneratedFiles(testFilePath, sourceFilePath, logger) {
-  try {
-    execSync(`git add "${sourceFilePath}" "${testFilePath}"`, { stdio: 'pipe' });
-    const name = basename(sourceFilePath);
-    execSync(`git commit -m "test: 為 ${name} 新增自動生成的測試"`, { stdio: 'pipe' });
-    logger.success('原始碼與測試檔案已自動 commit。');
-  } catch {
-    logger.warning('無法自動 commit 產生的檔案（可能沒有 staged 變更或不在 git 倉庫中）。');
-  }
+  const name = basename(sourceFilePath).replace(/\.(js|jsx|ts|tsx|mjs|cjs)$/, '');
+  const ext = /\.(ts|tsx)$/.test(sourceFilePath) ? '.ts' : '.js';
+  const suffix = testType === 'component' ? 'component' : 'unit';
+  return join(dir, '__tests__', `${name}.${suffix}.test${ext}`);
 }

package/src/core/test-runner.js

@@ -10,17 +10,23 @@ import { resolve } from 'path';
 export class TestRunner {
   /**
    * 執行指定的測試檔案
-   * @param {string} testFilePath - 測試檔案路徑（絕對路徑）
+   * @param {string|string[]} testFilePath - 測試檔案路徑（絕對路徑）
    * @returns {Promise<{ success: boolean, errors: string[] }>}
    */
   static async runTests(testFilePath) {
-    if (!existsSync(testFilePath)) {
-      return { success: false, errors: [`測試檔案不存在：${testFilePath}`] };
+    const testFilePaths = Array.isArray(testFilePath) ? testFilePath : [testFilePath];
+    const missingTestFilePath = testFilePaths.find((filePath) => !existsSync(filePath));
+
+    if (missingTestFilePath) {
+      return { success: false, errors: [`測試檔案不存在：${missingTestFilePath}`] };
     }
 
     try {
-      const absoluteTestFilePath = resolve(testFilePath);
-      execSync(`npx jest --runInBand --runTestsByPath "${absoluteTestFilePath}" --no-coverage`, {
+      const absoluteTestFilePaths = testFilePaths
+        .map((filePath) => `"${resolve(filePath)}"`)
+        .join(' ');
+
+      execSync(`npx jest --runInBand --runTestsByPath ${absoluteTestFilePaths} --no-coverage`, {
         encoding: 'utf-8',
         stdio: 'pipe',
         timeout: 120000, // 2 分鐘超時