ai-git-tools 2.0.61 → 2.0.63

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', '全自動模式，跳過所有確認')
@@ -172,6 +172,7 @@ program
       await autoDevCommand(options);
       process.exit(0);
     } catch (error) {
+      console.error(`\n[錯誤] ${error.message}`);
       process.exit(1);
     }
   });

package/package.json

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

package/src/commands/auto-dev.js

@@ -5,15 +5,11 @@
  */
 
 import { resolve } from 'path';
-import { existsSync, readFileSync } from 'fs';
-import { execSync } from 'child_process';
 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 { TestGenerator } from '../core/test-generator.js';
-import { writeAndTestCommand, TEST_TYPE_CHOICES, normalizeTestType } from './write-and-test.js';
+import { writeAndTestCommand, TEST_TYPE_CHOICES, normalizeTestTypeSelection } from './write-and-test.js';
 import { Logger } from '../utils/logger.js';
 
 export async function autoDevCommand(options = {}) {
@@ -125,11 +121,6 @@ export async function autoDevCommand(options = {}) {
     requestedTestType: options.testType,
   });
 
-  const resolvedRuntimeTestType = resolveRuntimeTestType(absoluteFilePath, selectedTestType);
-
-  logger.step('正在驗證專案可用的測試腳本...');
-  ensureJestAvailable(resolvedRuntimeTestType);
-  logger.success('已確認可執行 Jest 測試。');
   console.log('');
 
   // ============================================================
@@ -149,25 +140,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 + ' (程式碼)'}`);
 }
 
@@ -257,8 +238,10 @@ function getLanguageFromFilePath(filePath) {
 }
 
 async function resolveTestTypeForAutoDev({ noConfirm, requestedTestType }) {
+  const defaultTestType = normalizeTestTypeSelection(requestedTestType || 'auto')[0] || 'auto';
+
   if (noConfirm) {
-    return normalizeTestType(requestedTestType || 'auto');
+    return requestedTestType || 'auto';
   }
 
   const { testType } = await inquirer.prompt([{
@@ -266,75 +249,8 @@ async function resolveTestTypeForAutoDev({ noConfirm, requestedTestType }) {
     name: 'testType',
     message: '請選擇這次要執行的測試方式：',
     choices: TEST_TYPE_CHOICES,
-    default: normalizeTestType(requestedTestType || 'auto'),
+    default: defaultTestType === 'auto' ? 'both' : defaultTestType,
   }]);
 
-  return normalizeTestType(testType);
-}
-
-function resolveRuntimeTestType(sourceFilePath, requestedTestType) {
-  if (requestedTestType !== 'auto') {
-    return requestedTestType;
-  }
-
-  const sourceCode = readFileSync(sourceFilePath, 'utf-8');
-  return TestGenerator.resolveTestType(sourceFilePath, sourceCode, 'auto');
-}
-
-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 hasJestDependency = Boolean(
-      packageJson.dependencies?.jest || packageJson.devDependencies?.jest
-    );
-
-    if (!hasJestDependency) {
-      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 !== '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。');
-  }
+  return testType;
 }

package/src/commands/generate-code.js

@@ -8,7 +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 } from './write-and-test.js';
+import { writeAndTestCommand, TEST_TYPE_CHOICES, normalizeTestTypeSelection } from './write-and-test.js';
 import { Logger } from '../utils/logger.js';
 
 export async function generateCodeCommand(options = {}) {
@@ -97,13 +97,13 @@ export async function generateCodeCommand(options = {}) {
           value: 'skip',
         },
       ],
-      default: 'auto',
+      default: 'both',
     }]);
 
     if (nextAction !== 'skip') {
       await writeAndTestCommand({
         file: filePath,
-        testType: nextAction,
+        testType: normalizeTestTypeSelection(nextAction).join(','),
         maxFixes: options.maxFixes || '2',
         model: options.model,
         noConfirm: true,

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

@@ -4,8 +4,7 @@
  */
 
 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';
@@ -24,31 +23,75 @@ export const TEST_TYPE_CHOICES = [
     name: '寫元件測試',
     value: 'component',
   },
+  {
+    name: '同時寫 Jest 單元測試 + 元件測試',
+    value: 'both',
+  },
 ];
 
-export function normalizeTestType(testType = 'auto') {
-  const normalized = String(testType).trim().toLowerCase();
+export function normalizeTestTypeSelection(testType = 'auto') {
+  const rawValues = Array.isArray(testType)
+    ? testType
+    : String(testType)
+      .split(',')
+      .map((value) => value.trim())
+      .filter(Boolean);
 
-  if (normalized === 'auto' || normalized === 'unit' || normalized === 'component') {
-    return normalized;
-  }
+  const normalizedValues = rawValues.length > 0 ? rawValues : ['auto'];
+  const resolvedValues = normalizedValues.flatMap((value) => {
+    const normalized = value.toLowerCase();
 
-  if (normalized === 'jest' || normalized === 'jest-unit' || normalized === 'unit-test') {
-    return 'unit';
-  }
+    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 (normalized === 'component-test' || normalized === 'react-component') {
-    return 'component';
+  if (!normalizedTestTypes.includes('auto')) {
+    return normalizedTestTypes;
   }
 
-  throw new Error(`不支援的測試類型：${testType}`);
+  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 = normalizeTestType(options.testType || 'auto');
   const maxFixes = parseInt(options.maxFixes || '2', 10);
 
   if (!filePath) {
@@ -62,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('');
 
@@ -77,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,
     }]);
 
@@ -89,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 = [];
@@ -108,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;
@@ -139,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),
       };
     }
   }
@@ -152,25 +205,11 @@ export async function writeAndTestCommand(options = {}) {
 
 /**
  * 依據原始檔案路徑推導測試檔案路徑
- * e.g. src/core/foo.js → src/core/__tests__/foo.test.js
  */
-export function deriveTestFilePath(sourceFilePath) {
+export function deriveTestFilePath(sourceFilePath, testType = 'unit') {
   const dir = dirname(sourceFilePath);
   const name = basename(sourceFilePath).replace(/\.(js|jsx|ts|tsx|mjs|cjs)$/, '');
   const ext = /\.(ts|tsx)$/.test(sourceFilePath) ? '.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 suffix = testType === 'component' ? 'component' : 'unit';
+  return join(dir, '__tests__', `${name}.${suffix}.test${ext}`);
 }

package/src/core/test-runner.js

@@ -1,36 +1,86 @@
 /**
  * TestRunner 服務
- * 執行 Jest 測試、解析結果，並在失敗時觸發自動修復（最多 2 次）
+ * 執行 Jest / bun test 測試、解析結果，並在失敗時觸發自動修復（最多 2 次）
  */
 
 import { execSync } from 'child_process';
-import { existsSync } from 'fs';
+import { existsSync, readFileSync } from 'fs';
 import { resolve } from 'path';
 
+/**
+ * 偵測目前專案使用的測試執行器
+ * 優先順序：bun test > vitest > jest
+ */
+function detectTestRunner() {
+  const packageJsonPath = resolve(process.cwd(), 'package.json');
+  if (!existsSync(packageJsonPath)) {
+    return 'jest';
+  }
+
+  try {
+    const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+    const allDeps = {
+      ...pkg.dependencies,
+      ...pkg.devDependencies,
+    };
+
+    // 偵測 bun：test 腳本含 bun test，或安裝了 bun
+    const testScript = pkg.scripts?.test || '';
+    if (testScript.includes('bun test')) {
+      return 'bun';
+    }
+
+    // 偵測 vitest
+    if (allDeps.vitest) {
+      return 'vitest';
+    }
+
+    return 'jest';
+  } catch {
+    return 'jest';
+  }
+}
+
 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}`] };
     }
 
+    const runner = detectTestRunner();
+
     try {
-      const absoluteTestFilePath = resolve(testFilePath);
-      execSync(`npx jest --runInBand --runTestsByPath "${absoluteTestFilePath}" --no-coverage`, {
+      const absoluteTestFilePaths = testFilePaths.map((filePath) => `"${resolve(filePath)}"`);
+
+      let cmd;
+      if (runner === 'bun') {
+        // bun test 接受多個檔案作為參數
+        cmd = `bun test ${absoluteTestFilePaths.join(' ')}`;
+      } else if (runner === 'vitest') {
+        cmd = `npx vitest run ${absoluteTestFilePaths.join(' ')}`;
+      } else {
+        cmd = `npx jest --runInBand --runTestsByPath ${absoluteTestFilePaths.join(' ')} --no-coverage`;
+      }
+
+      execSync(cmd, {
         encoding: 'utf-8',
         stdio: 'pipe',
         timeout: 120000, // 2 分鐘超時
         cwd: process.cwd(),
       });
-      return { success: true, errors: [] };
+      return { success: true, errors: [], runner };
     } catch (error) {
       const output = (error.stdout || '') + (error.stderr || '');
       const errors = TestRunner._parseErrors(output);
-      return { success: false, errors };
+      return { success: false, errors, runner };
     }
   }