@monaco-ai-editor/core 0.1.0

package/src/completion/sqlCompletion.ts

@@ -0,0 +1,151 @@
+import type * as MonacoType from 'monaco-editor';
+import { SQL_KEYWORDS, SQL_FUNCTIONS, SQL_DATA_TYPES } from '../constants';
+import type { SqlSchema } from '../types';
+
+/** 从 SQL 文档中动态解析表名、CTE 别名和变量 */
+function parseDynamicItems(sql: string): { tables: string[]; variables: string[] } {
+  const tables: string[] = [];
+  const variables: string[] = [];
+  let m: RegExpExecArray | null;
+
+  const tableRe = /\b(?:FROM|JOIN|UPDATE|INTO|TABLE)\s+([`"']?\w+[`"']?)/gi;
+  while ((m = tableRe.exec(sql)) !== null) {
+    const name = m[1].replace(/[`"']/g, '');
+    if (!tables.includes(name)) tables.push(name);
+  }
+
+  const cteRe = /\bWITH\s+(\w+)\s+AS\s*\(/gi;
+  while ((m = cteRe.exec(sql)) !== null) {
+    if (!tables.includes(m[1])) tables.push(m[1]);
+  }
+
+  const declareRe = /\bDECLARE\s+(@?\w+)/gi;
+  while ((m = declareRe.exec(sql)) !== null) {
+    if (!variables.includes(m[1])) variables.push(m[1]);
+  }
+
+  const setVarRe = /\bSET\s+(@\w+)\s*=/gi;
+  while ((m = setVarRe.exec(sql)) !== null) {
+    if (!variables.includes(m[1])) variables.push(m[1]);
+  }
+
+  const atVarRe = /@(\w+)/g;
+  while ((m = atVarRe.exec(sql)) !== null) {
+    const v = `@${m[1]}`;
+    if (!variables.includes(v)) variables.push(v);
+  }
+
+  return { tables, variables };
+}
+
+/**
+ * 注册 SQL 内置补全提供者。
+ * schemaRef 使用 ref 模式以支持动态更新。
+ * excludeLabelsRef（可选）使用 ref 模式，提供需要从内置关键字/函数中排除的 label
+ * （大写匹配）。用于让使用方的自定义词表覆盖内置同名项，避免重复提示。
+ */
+export function registerSqlCompletion(
+  monaco: typeof MonacoType,
+  schemaRef: { readonly current: SqlSchema },
+  excludeLabelsRef?: { readonly current: Set<string> },
+): MonacoType.IDisposable {
+  return monaco.languages.registerCompletionItemProvider('sql', {
+    triggerCharacters: ['.'],
+    provideCompletionItems(model, position, context) {
+      const word = model.getWordUntilPosition(position);
+      const range: MonacoType.IRange = {
+        startLineNumber: position.lineNumber,
+        endLineNumber: position.lineNumber,
+        startColumn: word.startColumn,
+        endColumn: word.endColumn,
+      };
+
+      // 点号触发：提示该表的列名
+      if (context.triggerCharacter === '.') {
+        const lineText = model.getLineContent(position.lineNumber);
+        const textBeforeDot = lineText.substring(0, position.column - 2);
+        const tableMatch = textBeforeDot.match(/(\w+)$/);
+        if (tableMatch) {
+          const typed = tableMatch[1].toUpperCase();
+          const schema = schemaRef.current;
+          const tableKey = Object.keys(schema).find((k) => k.toUpperCase() === typed);
+          if (tableKey) {
+            const colRange: MonacoType.IRange = {
+              startLineNumber: position.lineNumber,
+              endLineNumber: position.lineNumber,
+              startColumn: position.column,
+              endColumn: position.column,
+            };
+            return {
+              suggestions: schema[tableKey].map((col) => ({
+                label: col,
+                kind: monaco.languages.CompletionItemKind.Field,
+                insertText: col,
+                range: colRange,
+                detail: `${tableKey} · 列`,
+                documentation: `表 ${tableKey} 的字段`,
+              })),
+            };
+          }
+        }
+        return { suggestions: [] };
+      }
+
+      // 普通触发：关键字 + 函数 + 类型 + 表名 + 变量
+      const fullText = model.getValue();
+      const { tables: dynamicTables, variables } = parseDynamicItems(fullText);
+      const schema = schemaRef.current;
+      const schemaTables = Object.keys(schema);
+      const allTables = [...new Set([...schemaTables, ...dynamicTables])];
+
+      // 需要排除的内置 label（大写匹配），让使用方自定义词表覆盖同名项
+      const exclude = excludeLabelsRef?.current;
+      const isExcluded = (label: string) => exclude?.has(label.toUpperCase()) ?? false;
+
+      const keywords = SQL_KEYWORDS.filter((kw) => !isExcluded(kw)).map((kw) => ({
+        label: kw,
+        kind: monaco.languages.CompletionItemKind.Keyword,
+        insertText: kw,
+        range,
+        detail: 'SQL 关键字',
+      }));
+
+      const functions = SQL_FUNCTIONS.filter((fn) => !isExcluded(fn)).map((fn) => ({
+        label: fn,
+        kind: monaco.languages.CompletionItemKind.Function,
+        insertText: `${fn}($1)`,
+        insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+        range,
+        detail: 'SQL 函数',
+      }));
+
+      const dataTypes = SQL_DATA_TYPES.map((dt) => ({
+        label: dt,
+        kind: monaco.languages.CompletionItemKind.TypeParameter,
+        insertText: dt,
+        range,
+        detail: 'SQL 数据类型',
+      }));
+
+      const tableItems = allTables.map((t) => ({
+        label: t,
+        kind: monaco.languages.CompletionItemKind.Class,
+        insertText: t,
+        range,
+        detail: schemaTables.includes(t) ? '表名 (Schema)' : '表名 (文档)',
+      }));
+
+      const variableItems = variables.map((v) => ({
+        label: v,
+        kind: monaco.languages.CompletionItemKind.Variable,
+        insertText: v,
+        range,
+        detail: 'SQL 变量',
+      }));
+
+      return {
+        suggestions: [...keywords, ...functions, ...dataTypes, ...tableItems, ...variableItems],
+      };
+    },
+  });
+}

package/src/constants.ts

@@ -0,0 +1,71 @@
+export const SQL_KEYWORDS = [
+  'SELECT', 'FROM', 'WHERE', 'INSERT', 'INTO', 'VALUES', 'UPDATE', 'SET', 'DELETE',
+  'CREATE', 'TABLE', 'DROP', 'ALTER', 'ADD', 'COLUMN', 'INDEX', 'VIEW', 'DATABASE',
+  'SCHEMA', 'TRUNCATE', 'RENAME', 'AS', 'ON', 'JOIN', 'INNER', 'LEFT', 'RIGHT',
+  'FULL', 'OUTER', 'CROSS', 'NATURAL', 'USING', 'AND', 'OR', 'NOT', 'IN', 'EXISTS',
+  'BETWEEN', 'LIKE', 'IS', 'NULL', 'TRUE', 'FALSE', 'CASE', 'WHEN', 'THEN', 'ELSE',
+  'END', 'IF', 'UNION', 'ALL', 'DISTINCT', 'ORDER', 'BY', 'ASC', 'DESC', 'GROUP',
+  'HAVING', 'LIMIT', 'OFFSET', 'FETCH', 'NEXT', 'ROWS', 'ONLY', 'WITH', 'RECURSIVE',
+  'PRIMARY', 'KEY', 'FOREIGN', 'REFERENCES', 'UNIQUE', 'NOT NULL', 'DEFAULT',
+  'CHECK', 'CONSTRAINT', 'AUTO_INCREMENT', 'IDENTITY', 'SEQUENCE', 'GRANT',
+  'REVOKE', 'COMMIT', 'ROLLBACK', 'TRANSACTION', 'BEGIN', 'SAVEPOINT', 'EXPLAIN',
+];
+
+export const SQL_FUNCTIONS = [
+  'COUNT', 'SUM', 'AVG', 'MIN', 'MAX', 'COALESCE', 'NULLIF', 'IFNULL', 'NVL',
+  'CONCAT', 'LENGTH', 'SUBSTR', 'SUBSTRING', 'TRIM', 'LTRIM', 'RTRIM', 'UPPER',
+  'LOWER', 'REPLACE', 'INSTR', 'LPAD', 'RPAD', 'CHAR_LENGTH', 'POSITION',
+  'NOW', 'CURDATE', 'CURTIME', 'DATE', 'TIME', 'YEAR', 'MONTH', 'DAY',
+  'HOUR', 'MINUTE', 'SECOND', 'DATEDIFF', 'DATE_ADD', 'DATE_SUB', 'DATEADD',
+  'DATESUB', 'EXTRACT', 'TO_DATE', 'TO_CHAR', 'DATE_FORMAT', 'TIMESTAMPDIFF',
+  'ROUND', 'CEIL', 'FLOOR', 'ABS', 'MOD', 'POWER', 'SQRT', 'SIGN', 'RAND',
+  'CAST', 'CONVERT', 'ROW_NUMBER', 'RANK', 'DENSE_RANK', 'NTILE', 'LAG', 'LEAD',
+  'FIRST_VALUE', 'LAST_VALUE', 'OVER', 'PARTITION', 'LISTAGG', 'GROUP_CONCAT',
+  'STRING_AGG', 'JSON_OBJECT', 'JSON_ARRAY', 'JSON_EXTRACT', 'ISNULL',
+];
+
+export const SQL_DATA_TYPES = [
+  'INT', 'INTEGER', 'BIGINT', 'SMALLINT', 'TINYINT', 'DECIMAL', 'NUMERIC',
+  'FLOAT', 'DOUBLE', 'REAL', 'CHAR', 'VARCHAR', 'TEXT', 'NCHAR', 'NVARCHAR',
+  'NTEXT', 'DATE', 'TIME', 'DATETIME', 'TIMESTAMP', 'BOOLEAN', 'BOOL',
+  'BLOB', 'CLOB', 'BINARY', 'VARBINARY', 'JSON', 'UUID', 'SERIAL',
+];
+
+export const LANGUAGES = [
+  'javascript',
+  'typescript',
+  'python',
+  'json',
+  'css',
+  'html',
+  'markdown',
+  'rust',
+  'go',
+  'sql',
+] as const;
+
+/** Monaco 编辑器支持的 UI 本地化语言 */
+export const LOCALES = {
+  ZH_CN: 'zh-cn',
+  EN: 'en',
+  DE: 'de',
+  ES: 'es',
+  FR: 'fr',
+  IT: 'it',
+  JA: 'ja',
+  KO: 'ko',
+  RU: 'ru',
+} as const;
+
+export type Locale = (typeof LOCALES)[keyof typeof LOCALES];
+
+export const THEMES = [
+  { value: 'vs-dark', label: 'Dark' },
+  { value: 'light', label: 'Light' },
+  { value: 'hc-black', label: 'High Contrast' },
+] as const;
+
+export const AI_INLINE_LANGUAGES = [
+  'typescript', 'javascript', 'python', 'sql',
+  'java', 'cpp', 'csharp', 'go', 'rust',
+];

package/src/controllers/AiChatController.ts

@@ -0,0 +1,198 @@
+import { EventEmitter } from '../bus/EventEmitter';
+import type { ApiConfig, ChatMessage } from '../types';
+
+export interface AiChatControllerEvents {
+  messageAdded: ChatMessage;
+  messageUpdated: ChatMessage;
+  cleared: void;
+  loadingChange: { loading: boolean };
+  error: { message: string };
+}
+
+function generateUUID(): string {
+  if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+    return crypto.randomUUID();
+  }
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+    const r = (Math.random() * 16) | 0;
+    const v = c === 'x' ? r : (r & 0x3) | 0x8;
+    return v.toString(16);
+  });
+}
+
+/**
+ * AI 聊天控制器：管理消息列表、API 调用与流式响应。
+ * 框架无关：通过事件通知 UI 层更新。
+ */
+export class AiChatController extends EventEmitter<AiChatControllerEvents> {
+  private messages: ChatMessage[] = [];
+  private abortController: AbortController | null = null;
+  private loading = false;
+  private apiConfig: ApiConfig;
+
+  constructor(apiConfig: ApiConfig) {
+    super();
+    this.apiConfig = apiConfig;
+  }
+
+  setApiConfig(config: ApiConfig): void {
+    this.apiConfig = config;
+  }
+
+  getApiConfig(): ApiConfig {
+    return this.apiConfig;
+  }
+
+  getMessages(): readonly ChatMessage[] {
+    return this.messages;
+  }
+
+  isLoading(): boolean {
+    return this.loading;
+  }
+
+  /** 发送消息，可选携带编辑器上下文 */
+  async send(
+    userInput: string,
+    options?: { editorContent?: string; language?: string },
+  ): Promise<void> {
+    const trimmed = userInput.trim();
+    if (!trimmed || this.loading) return;
+
+    if (!this.apiConfig.apiKey.trim()) {
+      const userMsg: ChatMessage = { id: generateUUID(), role: 'user', content: trimmed };
+      this.messages.push(userMsg);
+      this.emit('messageAdded', userMsg);
+      const assistantMsg: ChatMessage = {
+        id: generateUUID(),
+        role: 'assistant',
+        content: '⚠️ 尚未配置 API Key，请配置 Base URL、API Key 和模型名称后再开始对话。',
+      };
+      this.messages.push(assistantMsg);
+      this.emit('messageAdded', assistantMsg);
+      return;
+    }
+
+    const userMsg: ChatMessage = { id: generateUUID(), role: 'user', content: trimmed };
+    this.messages.push(userMsg);
+    this.emit('messageAdded', userMsg);
+
+    const assistantMsg: ChatMessage = {
+      id: generateUUID(),
+      role: 'assistant',
+      content: '',
+      isStreaming: true,
+    };
+    this.messages.push(assistantMsg);
+    this.emit('messageAdded', assistantMsg);
+
+    this.loading = true;
+    this.emit('loadingChange', { loading: true });
+
+    try {
+      this.abortController = new AbortController();
+
+      const systemPrompt = options?.language
+        ? `You are an expert coding assistant. The user is working with ${options.language} code. Respond concisely in the same language as the user's message, defaulting to Chinese.`
+        : "You are an expert coding assistant. Respond concisely in the same language as the user's message, defaulting to Chinese.";
+
+      const historyForApi = this.messages
+        .filter((m) => m.id !== assistantMsg.id)
+        .map((m) => ({ role: m.role, content: m.content }));
+
+      const response = await fetch(`${this.apiConfig.baseUrl}/chat/completions`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${this.apiConfig.apiKey}`,
+        },
+        body: JSON.stringify({
+          model: this.apiConfig.model,
+          messages: [{ role: 'system', content: systemPrompt }, ...historyForApi],
+          stream: true,
+        }),
+        signal: this.abortController.signal,
+      });
+
+      if (!response.ok) {
+        let errText = '';
+        try {
+          errText = await response.text();
+        } catch {
+          /* ignore */
+        }
+        let hint = '';
+        if (response.status === 401) hint = '（API Key 无效或已过期）';
+        else if (response.status === 403) hint = '（无访问权限，请检查 API Key 和 Base URL）';
+        else if (response.status === 429) hint = '（请求过于频繁，请稍后再试）';
+        else if (response.status >= 500) hint = '（服务端错误）';
+        throw new Error(`HTTP ${response.status}${hint}${errText ? `\n${errText}` : ''}`);
+      }
+
+      const reader = response.body!.getReader();
+      const decoder = new TextDecoder();
+      let buffer = '';
+      let fullContent = '';
+
+      // eslint-disable-next-line no-constant-condition
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() ?? '';
+        for (const line of lines) {
+          if (!line.startsWith('data: ')) continue;
+          const data = line.slice(6).trim();
+          if (data === '[DONE]') break;
+          try {
+            const parsed = JSON.parse(data) as {
+              choices?: Array<{ delta?: { content?: string } }>;
+            };
+            const delta = parsed.choices?.[0]?.delta?.content ?? '';
+            if (delta) {
+              fullContent += delta;
+              assistantMsg.content = fullContent;
+              this.emit('messageUpdated', { ...assistantMsg });
+            }
+          } catch {
+            /* ignore */
+          }
+        }
+      }
+
+      assistantMsg.isStreaming = false;
+      this.emit('messageUpdated', { ...assistantMsg });
+    } catch (err: unknown) {
+      const isAbort = err instanceof Error && err.name === 'AbortError';
+      const errMsg = err instanceof Error ? err.message : String(err);
+      const isNetworkErr = err instanceof TypeError && errMsg.toLowerCase().includes('fetch');
+      const errorContent = isAbort
+        ? '⏹ 请求已取消'
+        : isNetworkErr
+          ? `⚠️ 网络错误，请检查 Base URL 和网络。\n\n${errMsg}`
+          : `⚠️ 请求失败：${errMsg}`;
+      assistantMsg.content = errorContent;
+      assistantMsg.isStreaming = false;
+      this.emit('messageUpdated', { ...assistantMsg });
+      if (!isAbort) this.emit('error', { message: errMsg });
+    } finally {
+      this.loading = false;
+      this.emit('loadingChange', { loading: false });
+    }
+  }
+
+  stop(): void {
+    this.abortController?.abort();
+  }
+
+  clear(): void {
+    this.messages = [];
+    this.emit('cleared', undefined);
+  }
+
+  dispose(): void {
+    this.abortController?.abort();
+    this.removeAllListeners();
+  }
+}

package/src/controllers/EditorController.ts

@@ -0,0 +1,231 @@
+import type * as MonacoType from 'monaco-editor';
+import { EventEmitter } from '../bus/EventEmitter';
+import type { ApiConfig, PendingCompletion, SqlSchema, CompletionProvider } from '../types';
+import { registerSqlCompletion } from '../completion/sqlCompletion';
+import { registerAiInlineCompletion } from '../ai/aiCompletion';
+
+export interface EditorControllerEvents {
+  change: { value: string };
+  cursor: { line: number; column: number };
+  ready: { editor: MonacoType.editor.IStandaloneCodeEditor };
+  languageChange: { language: string };
+  focus: void;
+  blur: void;
+}
+
+export interface EditorControllerOptions {
+  container: HTMLElement;
+  language?: string;
+  theme?: string;
+  value?: string;
+  monaco: typeof MonacoType;
+  /** Monaco loader monaco-editor 路径配置 */
+  vsPath?: string;
+  sqlSchema?: SqlSchema;
+  apiConfig?: ApiConfig | null;
+  completionProviders?: CompletionProvider[];
+  /** Monaco editor options */
+  editorOptions?: MonacoType.editor.IStandaloneEditorConstructionOptions;
+}
+
+/**
+ * 框架无关的编辑器控制器。
+ * 封装 Monaco 实例的生命周期、核心操作、补全注册。
+ * 通过 EventEmitter 暴露编辑器事件，不依赖任何 UI 框架。
+ */
+export class EditorController extends EventEmitter<EditorControllerEvents> {
+  private editor: MonacoType.editor.IStandaloneCodeEditor | null = null;
+  private monaco: typeof MonacoType;
+  private sqlProviderRegistered = false;
+  private aiProviderRegistered = false;
+  private pendingCompletionRef = { current: null as PendingCompletion | null };
+  private customProviders: CompletionProvider[] = [];
+  private disposables: MonacoType.IDisposable[] = [];
+
+  completed = false;
+  error: Error | null = null;
+
+  constructor(private options: EditorControllerOptions) {
+    super();
+    this.monaco = options.monaco;
+    this.customProviders = options.completionProviders ?? [];
+    this.init();
+  }
+
+  private init(): void {
+    const { language, theme, value, sqlSchema, apiConfig, editorOptions } = this.options;
+
+    // 注册 SQL 补全（只注册一次）
+    if (!this.sqlProviderRegistered) {
+      const schemaRef = { current: sqlSchema ?? {} };
+      registerSqlCompletion(this.monaco, schemaRef);
+      this.sqlProviderRegistered = true;
+    }
+
+    // 注册 AI 幽灵文本提供者
+    if (!this.aiProviderRegistered) {
+      registerAiInlineCompletion(this.monaco, this.pendingCompletionRef);
+      this.aiProviderRegistered = true;
+    }
+
+    // 注册自定义补全提供者
+    this.registerCustomCompletionProviders();
+
+    // 创建编辑器
+    this.editor = this.monaco.editor.create(this.options.container, {
+      value: value ?? '',
+      language: language ?? 'typescript',
+      theme: theme ?? 'vs-dark',
+      fontSize: 14,
+      minimap: { enabled: true },
+      scrollBeyondLastLine: false,
+      automaticLayout: true,
+      lineNumbers: 'on',
+      renderLineHighlight: 'all',
+      smoothScrolling: true,
+      cursorBlinking: 'smooth',
+      bracketPairColorization: { enabled: true },
+      tabSize: 2,
+      wordWrap: 'on',
+      folding: true,
+      formatOnPaste: true,
+      suggestOnTriggerCharacters: true,
+      quickSuggestions: { other: true, comments: false, strings: false },
+      acceptSuggestionOnCommitCharacter: true,
+      acceptSuggestionOnEnter: 'on',
+      inlineSuggest: { enabled: true },
+      tabCompletion: 'on',
+      ...editorOptions,
+    });
+
+    // 绑定事件
+    this.bindEditorEvents();
+    this.emit('ready', { editor: this.editor });
+  }
+
+  private bindEditorEvents(): void {
+    const editor = this.editor!;
+
+    const d1 = editor.onDidChangeModelContent(() => {
+      this.emit('change', { value: editor.getValue() });
+    });
+
+    const d2 = editor.onDidChangeCursorPosition((e) => {
+      this.emit('cursor', {
+        line: e.position.lineNumber,
+        column: e.position.column,
+      });
+    });
+
+    const d3 = editor.onDidFocusEditorText(() => this.emit('focus', undefined));
+    const d4 = editor.onDidBlurEditorText(() => this.emit('blur', undefined));
+
+    this.disposables.push(d1, d2, d3, d4);
+  }
+
+  private registerCustomCompletionProviders(): void {
+    if (this.customProviders.length === 0) return;
+
+    for (const provider of this.customProviders) {
+      const langs = provider.languages ?? ['*'];
+      for (const lang of langs) {
+        this.monaco.languages.registerCompletionItemProvider(lang, {
+          triggerCharacters: provider.triggerCharacters,
+          provideCompletionItems: async (model, position, context) => {
+            const ctx = {
+              monaco: this.monaco,
+              model,
+              position,
+              lineText: model.getLineContent(position.lineNumber),
+              currentWord: model.getWordUntilPosition(position).word,
+              fullText: model.getValue(),
+              triggerCharacter: context.triggerCharacter,
+            };
+
+            if (provider.shouldTrigger && !provider.shouldTrigger(ctx)) {
+              return { suggestions: [] };
+            }
+
+            const suggestions = await provider.provide(ctx);
+            return { suggestions };
+          },
+        });
+      }
+    }
+  }
+
+  // ─── 公开 API ──────────────────────────────────────────────────────────
+
+  getEditor(): MonacoType.editor.IStandaloneCodeEditor | null {
+    return this.editor;
+  }
+
+  getValue(): string {
+    return this.editor?.getValue() ?? '';
+  }
+
+  setValue(value: string): void {
+    this.editor?.setValue(value);
+  }
+
+  insertText(text: string, range?: MonacoType.IRange): void {
+    const editor = this.editor;
+    if (!editor) return;
+    const targetRange = range ?? editor.getSelection();
+    if (targetRange) {
+      editor.executeEdits('controller-insert', [{ range: targetRange, text }]);
+      editor.focus();
+    }
+  }
+
+  format(): void {
+    this.editor?.getAction('editor.action.formatDocument')?.run();
+  }
+
+  focus(): void {
+    this.editor?.focus();
+  }
+
+  setLanguage(language: string): void {
+    const model = this.editor?.getModel();
+    if (model) {
+      this.monaco.editor.setModelLanguage(model, language);
+      this.emit('languageChange', { language });
+    }
+  }
+
+  setTheme(theme: string): void {
+    this.monaco.editor.setTheme(theme);
+  }
+
+  getCursorPosition(): { line: number; column: number } {
+    const pos = this.editor?.getPosition();
+    return pos
+      ? { line: pos.lineNumber, column: pos.column }
+      : { line: 1, column: 1 };
+  }
+
+  getSelection(): MonacoType.IRange | null {
+    return this.editor?.getSelection() ?? null;
+  }
+
+  /**
+   * 触发 AI 行内补全（Ctrl+Alt+L 快捷键）。
+   * 需要提前设置 apiConfig（通过 setApiConfig 或构造函数传入）。
+   */
+  setApiConfig(config: ApiConfig | null): void {
+    this.options.apiConfig = config;
+  }
+
+  getPendingCompletionRef(): { current: PendingCompletion | null } {
+    return this.pendingCompletionRef;
+  }
+
+  dispose(): void {
+    for (const d of this.disposables) d.dispose();
+    this.disposables = [];
+    this.editor?.dispose();
+    this.editor = null;
+    this.removeAllListeners();
+  }
+}

package/src/index.ts

@@ -0,0 +1,47 @@
+// ─── 类型 ──────────────────────────────────────────────────────────────
+export type {
+  ApiConfig,
+  SqlSchema,
+  PendingCompletion,
+  ChatMessage,
+  EditorSnapshot,
+  CompletionContext,
+  CompletionProvider,
+} from './types';
+
+// ─── 常量 ──────────────────────────────────────────────────────────────
+export {
+  SQL_KEYWORDS,
+  SQL_FUNCTIONS,
+  SQL_DATA_TYPES,
+  LANGUAGES,
+  THEMES,
+  AI_INLINE_LANGUAGES,
+  LOCALES,
+  type Locale,
+} from './constants';
+
+// ─── 控制器 ────────────────────────────────────────────────────────────
+export {
+  EditorController,
+  type EditorControllerOptions,
+  type EditorControllerEvents,
+} from './controllers/EditorController';
+
+export {
+  AiChatController,
+  type AiChatControllerEvents,
+} from './controllers/AiChatController';
+
+// ─── 总线 ──────────────────────────────────────────────────────────────
+export { EditorBus, type EditorBusEvents } from './bus/EditorBus';
+export { EventEmitter, type Listener } from './bus/EventEmitter';
+
+// ─── 补全 / AI ────────────────────────────────────────────────────────
+export { registerSqlCompletion } from './completion/sqlCompletion';
+export {
+  registerAiInlineCompletion,
+  registerAiCompletionCommand,
+  fetchAiCompletionStream,
+  fetchAiCompletionNonStream,
+} from './ai/aiCompletion';