@opensumi/ide-ai-native 3.9.1-next-1749452811.0 → 3.9.1-next-1749538805.0

package/src/browser/rules/rules.view.tsx

@@ -0,0 +1,127 @@
+import React, { useCallback, useEffect, useState } from 'react';
+
+import { Icon } from '@opensumi/ide-components';
+import { useInjectable } from '@opensumi/ide-core-browser';
+import { RulesServiceToken, localize } from '@opensumi/ide-core-common';
+
+import { ProjectRule } from '../../common/types';
+
+import styles from './rules.module.less';
+import { RulesService } from './rules.service';
+
+export const RulesView: React.FC = () => {
+  const rulesService = useInjectable<RulesService>(RulesServiceToken);
+  const [globalRules, setGlobalRules] = useState<string>(rulesService.globalRules as string);
+  const [projectRules, setProjectRules] = useState<ProjectRule[]>([]);
+
+  useEffect(() => {
+    setProjectRules(rulesService.projectRules);
+  }, [rulesService]);
+
+  const handleGlobalRulesChange = useCallback(
+    (e) => {
+      setGlobalRules(e.target.value);
+      rulesService.updateGlobalRules(e.target.value);
+    },
+    [rulesService, globalRules],
+  );
+
+  const handleCreateNewRule = useCallback(() => {
+    rulesService.createNewRule();
+  }, [rulesService]);
+
+  const handleOpenRule = useCallback(
+    (rule: ProjectRule) => {
+      rulesService.openRule(rule);
+    },
+    [rulesService],
+  );
+
+  const getFileNameFromPath = (path: string) => decodeURIComponent(path.split('/').pop() || path);
+
+  const hasWarning = (rule: ProjectRule) => !rule.description && !rule.alwaysApply && !rule.globs;
+
+  const getAppliesToText = (rule: ProjectRule) => {
+    if (rule.globs) {
+      if (Array.isArray(rule.globs)) {
+        return `Applies to: ${rule.globs.join(', ')}`;
+      } else {
+        return `Applies to: ${rule.globs}`;
+      }
+    }
+    return '';
+  };
+
+  useEffect(() => {
+    const disposable = rulesService.onRulesChange(() => {
+      setProjectRules(rulesService.projectRules);
+    });
+    return () => {
+      disposable.dispose();
+    };
+  }, []);
+
+  return (
+    <div className={styles.container}>
+      <div className={styles.header}>
+        <div>
+          <h2 className={styles.title}>{localize('ai.native.rules.title')}</h2>
+          <p className={styles.description}>{localize('ai.native.rules.description')}</p>
+        </div>
+      </div>
+      <div className={styles.user_rules}>
+        <div className={styles.user_rules_header}>
+          <h3 className={styles.title}>{localize('ai.native.rules.userRules.title')}</h3>
+          <p className={styles.description}>{localize('ai.native.rules.userRules.description')}</p>
+        </div>
+        <div className={styles.user_rules_content}>
+          <textarea
+            rows={6}
+            placeholder={localize('ai.native.rules.userRules.placeholder')}
+            value={globalRules}
+            onChange={handleGlobalRulesChange}
+            style={{ resize: 'none' }}
+          />
+        </div>
+      </div>
+      <div className={styles.project_rules}>
+        <div className={styles.project_rules_header}>
+          <div className={styles.project_rules_header_left}>
+            <h3 className={styles.title}>
+              {localize('ai.native.rules.projectRules.title')}
+              <button className={styles.actionButton} onClick={handleCreateNewRule}>
+                <Icon icon='plus' className={styles.actionButtonIcon} />
+                {localize('ai.native.rules.projectRules.newRule')}
+              </button>
+            </h3>
+            <p className={styles.description}>{localize('ai.native.rules.projectRules.description')}</p>
+          </div>
+        </div>
+        <div className={styles.project_rules_content}>
+          {projectRules.length > 0 ? (
+            <div className={styles.project_rules_list}>
+              {projectRules.map((rule, index) => (
+                <div key={index} className={styles.rule_item} onClick={() => handleOpenRule(rule)}>
+                  <div className={styles.rule_item_left}>
+                    <div className={styles.rule_filename}>{getFileNameFromPath(rule.path)}</div>
+                    {rule.description && <div className={styles.rule_description}>{rule.description}</div>}
+                    {hasWarning(rule) && (
+                      <div className={styles.rule_warning}>
+                        This rule may never be used since it has no description or auto attachments
+                      </div>
+                    )}
+                  </div>
+                  <div className={styles.rule_item_right}>
+                    {getAppliesToText(rule) && <div className={styles.rule_applies_to}>{getAppliesToText(rule)}</div>}
+                  </div>
+                </div>
+              ))}
+            </div>
+          ) : (
+            <div className={styles.empty_state}>{localize('ai.native.rules.projectRules.empty')}</div>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+};

package/src/browser/types.ts

@@ -5,6 +5,7 @@ import { ZodSchema } from 'zod';
 import { AIActionItem } from '@opensumi/ide-core-browser/lib/components/ai-native/index';
 import {
   CancellationToken,
+  ChatMessageRole,
   ChatResponse,
   Deferred,
   IAICompletionOption,
@@ -134,6 +135,8 @@ export interface IChatFeatureRegistry {
   registerImageUploadProvider(provider: IImageUploadProvider): void;
   registerWelcome(content: IChatWelcomeMessageContent | React.ReactNode, sampleQuestions?: ISampleQuestions[]): void;
   registerSlashCommand(command: IChatSlashCommandItem, handler: IChatSlashCommandHandler): void;
+
+  registerMessageSummaryProvider(provider: IMessageSummaryProvider): void;
 }
 
 export type ChatWelcomeRender = (props: {
@@ -298,6 +301,21 @@ export interface IImageUploadProvider {
   imageUpload(file: File): Promise<DataContent | URL>;
 }
 
+export interface IMessageSummaryProvider {
+  getMessageSummary(
+    messages: Array<{
+      role: ChatMessageRole;
+      content: string;
+    }>,
+  ): Promise<string | undefined>;
+  generateMemorizedMessage(
+    messages: Array<{
+      role: ChatMessageRole;
+      content: string;
+    }>,
+  ): Promise<string | undefined>;
+}
+
 export const AINativeCoreContribution = Symbol('AINativeCoreContribution');
 
 export interface AINativeCoreContribution {

package/src/browser/widget/inline-stream-diff/live-preview.component.tsx

@@ -13,7 +13,6 @@ import {
   Position,
 } from '@opensumi/ide-monaco';
 import { ReactInlineContentWidget } from '@opensumi/ide-monaco/lib/browser/ai-native/BaseInlineContentWidget';
-import { URI } from '@opensumi/ide-monaco/lib/browser/monaco-api';
 import { ContentWidgetPositionPreference } from '@opensumi/ide-monaco/lib/browser/monaco-exports/editor';
 import { EditorOption } from '@opensumi/monaco-editor-core/esm/vs/editor/common/config/editorOptions';
 import { IScrollEvent } from '@opensumi/monaco-editor-core/esm/vs/editor/common/editorCommon';

package/src/common/image-compression.ts

@@ -0,0 +1,174 @@
+import { isObject } from '@opensumi/ide-utils';
+
+import { IMCPToolResult, IMCPToolResultContent } from './types';
+
+export interface ImageCompressionOptions {
+  maxSizeKB?: number;
+  quality?: number;
+  maxWidth?: number;
+  maxHeight?: number;
+  mimeType?: string;
+}
+
+const DEFAULT_OPTIONS: Required<ImageCompressionOptions> = {
+  maxSizeKB: 500, // 500KB
+  quality: 0.8,
+  maxWidth: 1920,
+  maxHeight: 1080,
+  mimeType: 'image/jpeg',
+};
+
+/**
+ * 获取 base64 图像的大小（KB）
+ */
+export function getBase64ImageSize(base64String: string): number {
+  if (!base64String) {
+    return 0;
+  }
+
+  // 移除 data URL 前缀
+  const base64Data = base64String.split(',')[1] || base64String;
+
+  // Base64 编码后的大小约为原始大小的 4/3
+  const sizeInBytes = (base64Data.length * 3) / 4;
+  return sizeInBytes / 1024; // 转换为 KB
+}
+
+/**
+ * 使用 Canvas API 进行真正的图像压缩
+ */
+export function compressBase64Image(base64String: string, options: ImageCompressionOptions = {}): Promise<string> {
+  return new Promise((resolve) => {
+    try {
+      // 输入验证
+      if (!base64String || typeof base64String !== 'string') {
+        resolve(base64String || '');
+        return;
+      }
+      if (!base64String.startsWith('data:') && options.mimeType) {
+        base64String = `data:${options.mimeType};base64,${base64String}`;
+      }
+      const opts = { ...DEFAULT_OPTIONS, ...options };
+      const currentSize = getBase64ImageSize(base64String);
+      // 如果图像已经小于目标大小，直接返回
+      if (currentSize <= opts.maxSizeKB) {
+        resolve(base64String);
+        return;
+      }
+      // 创建图像对象
+      const img = new Image();
+      img.onload = () => {
+        try {
+          // 计算新的尺寸，保持宽高比
+          let { width, height } = img;
+          // 处理极小图片
+          if (width <= 1 || height <= 1) {
+            resolve(base64String);
+            return;
+          }
+          const aspectRatio = width / height;
+          if (width > opts.maxWidth) {
+            width = opts.maxWidth;
+            height = width / aspectRatio;
+          }
+          if (height > opts.maxHeight) {
+            height = opts.maxHeight;
+            width = height * aspectRatio;
+          }
+          const canvas = document.createElement('canvas');
+          const ctx = canvas.getContext('2d');
+          if (!ctx) {
+            resolve(base64String);
+            return;
+          }
+          canvas.width = Math.round(width);
+          canvas.height = Math.round(height);
+          ctx.drawImage(img, 0, 0, canvas.width, canvas.height);
+          let compressedBase64 = canvas.toDataURL(opts.mimeType, opts.quality);
+          let compressedSize = getBase64ImageSize(compressedBase64);
+          let currentQuality = opts.quality;
+          let attempts = 0;
+          const maxAttempts = 5;
+          while (compressedSize > opts.maxSizeKB && attempts < maxAttempts) {
+            currentQuality *= 0.6;
+            compressedBase64 = canvas.toDataURL(opts.mimeType, currentQuality);
+            compressedSize = getBase64ImageSize(compressedBase64);
+            attempts++;
+          }
+          const [, base64] = compressedBase64.split(',');
+          resolve(base64);
+        } catch (error) {
+          // 压缩失败，返回原始图像
+          resolve(base64String);
+        }
+      };
+      img.onerror = () => {
+        // 图像加载失败，返回原始字符串
+        resolve(base64String);
+      };
+      img.src = base64String;
+    } catch (error) {
+      resolve(base64String);
+    }
+  });
+}
+
+/**
+ * 压缩内容数组格式的工具结果
+ */
+export async function compressContentArrayResult(
+  result: IMCPToolResult,
+  options: ImageCompressionOptions = {},
+): Promise<IMCPToolResult> {
+  if (!result || !result.content || !Array.isArray(result.content)) {
+    return result;
+  }
+
+  const compressedContent = await Promise.all(
+    result.content.map(async (item) => {
+      if (item.type === 'image') {
+        let compressedData: string;
+        // 检测环境
+        if (typeof window !== 'undefined' && typeof document !== 'undefined') {
+          compressedData = await compressBase64Image(item.data, {
+            ...options,
+            mimeType: item.mimeType,
+          });
+        } else {
+          compressedData = item.data;
+        }
+
+        return {
+          ...item,
+          data: compressedData,
+        };
+      }
+      return item;
+    }),
+  );
+
+  return {
+    ...result,
+    content: compressedContent,
+  };
+}
+
+/**
+ * 智能压缩工具结果，支持多种格式
+ */
+export async function compressToolResultSmart(
+  result: IMCPToolResult,
+  options: ImageCompressionOptions = {},
+): Promise<any> {
+  if (
+    result &&
+    isObject(result) &&
+    result.content &&
+    Array.isArray(result.content) &&
+    result.content.some((item: IMCPToolResultContent) => item.type === 'image')
+  ) {
+    return await compressContentArrayResult(result, options);
+  }
+
+  return result;
+}

package/src/common/index.ts

@@ -15,8 +15,9 @@ import {
 import { DESIGN_MENUBAR_CONTAINER_VIEW_ID } from '@opensumi/ide-design/lib/common/constants';
 import { IPosition, ITextModel, InlineCompletionContext } from '@opensumi/ide-monaco/lib/common';
 
+import { ImageCompressionOptions } from './image-compression';
 import { IMCPServer, MCPServerDescription } from './mcp-server-manager';
-import { IPartialEditEvent, MCPTool } from './types';
+import { IMCPToolResult, IPartialEditEvent, MCPTool } from './types';
 
 import type { CoreMessage } from 'ai';
 
@@ -152,6 +153,7 @@ export interface ISumiMCPServerBackend {
   $removeServer(name: string): void;
   $syncServer(name: string): Promise<void>;
   $getMCPServerByName(name: string): IMCPServer | undefined;
+  $compressToolResult(result: IMCPToolResult, options: ImageCompressionOptions): Promise<IMCPToolResult>;
 }
 
 export const SumiMCPServerProxyServicePath = 'SumiMCPServerProxyServicePath';
@@ -331,3 +333,6 @@ export interface IInlineDiffService {
 }
 
 export const InlineDiffServiceToken = Symbol('InlineDiffService');
+
+export * from './tool-invocation-registry';
+export * from './mdc-parser';

package/src/common/llm-context.ts

@@ -1,5 +1,7 @@
 import { Event, URI } from '@opensumi/ide-core-common/lib/utils';
 
+import { ProjectRule } from './types';
+
 export interface LLMContextService {
   /**
    * 开始自动收集
@@ -21,6 +23,11 @@ export interface LLMContextService {
    */
   addFolderToContext(uri: URI, isManual?: boolean): void;
 
+  /**
+   * 添加规则到 context 中
+   */
+  addRuleToContext(uri: URI, isManual?: boolean): void;
+
   /**
    * 清除上下文
    */
@@ -33,6 +40,7 @@ export interface LLMContextService {
     viewed: FileContext[];
     attached: FileContext[];
     attachedFolders: FileContext[];
+    attachedRules: ProjectRule[];
     version: number;
   }>;
 
@@ -42,6 +50,18 @@ export interface LLMContextService {
    */
   removeFileFromContext(uri: URI, isManual?: boolean): void;
 
+  /**
+   * 从 context 中移除文件夹
+   * @param uri URI
+   */
+  removeFolderFromContext(uri: URI): void;
+
+  /**
+   * 从 context 中移除规则
+   * @param uri URI
+   */
+  removeRuleFromContext(uri: URI): void;
+
   /** 导出为可序列化格式 */
   serialize(): Promise<SerializedContext>;
 }
@@ -58,12 +78,15 @@ export interface AttachFileContext {
   lineErrors: string[];
   path: string;
   language: string;
+  selection?: [number, number];
 }
 
 export interface SerializedContext {
   recentlyViewFiles: string[];
   attachedFiles: Array<AttachFileContext>;
   attachedFolders: string[];
+  attachedRules: string[];
+  globalRules: string[];
 }
 
 export enum LLM_CONTEXT_KEY {