✨ feat(ai): 添加AI工具类和模型选择服务

- 【工具类】新增 generateHelper.ts，实现AI生成重试机制
- 【错误处理】添加错误类型枚举和重试选项配置
- 【模型服务】新增 ModelPickerService，支持动态选择AI模型
- 【UI交互】实现模型选择的QuickPick界面

Author: littleCareless

src/ai/utils/generateHelper.ts

@@ -0,0 +1,89 @@
+import { NotificationHandler } from "../../utils/NotificationHandler";
+import { LocalizationManager } from "../../utils/LocalizationManager";
+import { generateCommitMessageSystemPrompt } from "../../prompt/prompt";
+import { DEFAULT_CONFIG } from "../../config/default";
+import { AIRequestParams } from "../types";
+
+// 添加错误类型枚举
+export enum AIGenerationErrorType {
+  CONTEXT_LENGTH = "CONTEXT_LENGTH",
+  TOKEN_LIMIT = "TOKEN_LIMIT",
+  UNKNOWN = "UNKNOWN",
+}
+
+export interface GenerateWithRetryOptions {
+  maxRetries?: number;
+  initialMaxLength: number;
+  reductionFactor?: number;
+  provider: string;
+  retryableErrors?: AIGenerationErrorType[]; // 添加可重试的错误类型
+  retryDelay?: number; // 添加重试延迟时间
+}
+
+export async function generateWithRetry<T>(
+  params: AIRequestParams,
+  generateFn: (truncatedDiff: string) => Promise<T>,
+  options: GenerateWithRetryOptions
+): Promise<T> {
+  const {
+    maxRetries = 2,
+    initialMaxLength,
+    reductionFactor = 0.8,
+    provider,
+    retryableErrors = [
+      AIGenerationErrorType.CONTEXT_LENGTH,
+      AIGenerationErrorType.TOKEN_LIMIT,
+    ],
+    retryDelay = 1000,
+  } = options;
+
+  let retries = 0;
+  let maxInputLength = initialMaxLength;
+
+  while (true) {
+    try {
+      const truncatedPrompt = params.diff.substring(0, maxInputLength);
+
+      if (params.diff.length > maxInputLength) {
+        NotificationHandler.warn(
+          LocalizationManager.getInstance().getMessage(
+            `${provider}.input.truncated`
+          )
+        );
+      }
+
+      return await generateFn(truncatedPrompt);
+    } catch (error: any) {
+      console.log("error", error);
+      if (
+        retries < maxRetries &&
+        (error.message?.includes("maximum context length") ||
+          error.message?.includes("context length exceeded") ||
+          error.message?.includes("exceeds token limit"))
+      ) {
+        retries++;
+        maxInputLength = Math.floor(maxInputLength * reductionFactor);
+        continue;
+      }
+
+      const errorMessage = LocalizationManager.getInstance().format(
+        `${provider}.generation.failed`,
+        error.message || String(error)
+      );
+      NotificationHandler.error(errorMessage);
+      throw new Error(errorMessage);
+    }
+  }
+}
+
+export function getSystemPrompt(params: AIRequestParams): string {
+  return (
+    params.systemPrompt ||
+    generateCommitMessageSystemPrompt(
+      params.language || DEFAULT_CONFIG.language,
+      params.allowMergeCommits || false,
+      params.splitChangesInSingleFile || false,
+      params.scm || "git"
+    )
+  );
+}

src/services/ModelPickerService.ts

@@ -0,0 +1,83 @@
+import * as vscode from "vscode";
+import { AIProviderFactory } from "../ai/AIProviderFactory";
+import { NotificationHandler } from "../utils/NotificationHandler";
+import { LocalizationManager } from "../utils/LocalizationManager";
+
+export class ModelPickerService {
+  static async showModelPicker(
+    currentProvider: string,
+    currentModel: string
+  ): Promise<{ provider: string; model: string } | undefined> {
+    const locManager = LocalizationManager.getInstance();
+    try {
+      const providers = AIProviderFactory.getAllProviders();
+      const modelsMap = new Map<string, string[]>();
+
+      console.log("providers", providers);
+
+      const progressMsg = locManager.getMessage("ai.model.loading");
+      await vscode.window.withProgress(
+        {
+          location: vscode.ProgressLocation.Notification,
+          title: progressMsg,
+          cancellable: false,
+        },
+        async () => {
+          await Promise.all(
+            providers.map(async (provider) => {
+              if (await provider.isAvailable()) {
+                const models = await provider.getModels();
+                modelsMap.set(
+                  provider.getName(),
+                  models.map((model) => model.name)
+                );
+              }
+            })
+          );
+        }
+      );
+
+      const items: vscode.QuickPickItem[] = [];
+      for (const [provider, models] of modelsMap) {
+        items.push({
+          label: provider,
+          kind: vscode.QuickPickItemKind.Separator,
+        });
+        models.forEach((model) => {
+          items.push({
+            label: model,
+            description: provider,
+            picked: provider === currentProvider && model === currentModel,
+          });
+        });
+      }
+
+      const quickPick = vscode.window.createQuickPick();
+      quickPick.items = items;
+      quickPick.title = locManager.getMessage("ai.model.picker.title");
+      quickPick.placeholder = locManager.getMessage(
+        "ai.model.picker.placeholder"
+      );
+      quickPick.ignoreFocusOut = true;
+
+      const result = await new Promise<vscode.QuickPickItem | undefined>(
+        (resolve) => {
+          quickPick.onDidAccept(() => resolve(quickPick.selectedItems[0]));
+          quickPick.onDidHide(() => resolve(undefined));
+          quickPick.show();
+        }
+      );
+
+      quickPick.dispose();
+
+      if (result && result.description) {
+        return { provider: result.description, model: result.label };
+      }
+      return undefined;
+    } catch (error) {
+      console.error("获取模型列表失败:", error);
+      await NotificationHandler.error("model.list.failed");
+      return undefined;
+    }
+  }
+}