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

package/src/browser/components/mention-input/mention-select.tsx

@@ -0,0 +1,256 @@
+import cls from 'classnames';
+import React, { useEffect, useRef, useState } from 'react';
+
+import { ClickOutside } from '@opensumi/ide-components/lib/click-outside';
+import { Icon, getIcon } from '@opensumi/ide-core-browser/lib/components';
+
+import styles from './mention-select.module.less';
+
+export interface ExtendedModelOption {
+  label: string;
+  value: string;
+  icon?: string;
+  iconClass?: string;
+  tags?: string[];
+  features?: string[];
+  description?: string;
+  disabled?: boolean;
+  badge?: string;
+  badgeColor?: string;
+  selected?: boolean;
+}
+
+export interface MentionSelectProps {
+  options: ExtendedModelOption[];
+  value?: string;
+  onChange?: (value: string) => void;
+  placeholder?: string;
+  disabled?: boolean;
+  className?: string;
+  size?: 'small' | 'medium' | 'large';
+  showThinking?: boolean;
+  thinkingEnabled?: boolean;
+  onThinkingChange?: (enabled: boolean) => void;
+}
+
+const ThinkingToggle: React.FC<{
+  enabled: boolean;
+  onChange: (enabled: boolean) => void;
+}> = ({ enabled, onChange }) => (
+  <div className={styles.thinking_toggle} onClick={() => onChange(!enabled)}>
+    <Icon
+      iconClass={getIcon(enabled ? 'check' : 'circle-outline')}
+      className={cls(styles.thinking_icon, {
+        [styles.enabled]: enabled,
+      })}
+    />
+    <span className={styles.thinking_label}>Thinking</span>
+  </div>
+);
+
+export const MentionSelect: React.FC<MentionSelectProps> = ({
+  options,
+  value,
+  onChange,
+  placeholder,
+  disabled = false,
+  className,
+  size = 'small',
+  showThinking = false,
+  thinkingEnabled = false,
+  onThinkingChange,
+}) => {
+  const [isOpen, setIsOpen] = useState(false);
+  const [activeIndex, setActiveIndex] = useState(-1);
+  const [dropdownDirection, setDropdownDirection] = useState<'up' | 'down'>('up');
+  const selectRef = useRef<HTMLDivElement>(null);
+  const dropdownRef = useRef<HTMLDivElement>(null);
+
+  const selectedOption = options.find((option) => option.selected) || options.find((option) => option.value === value);
+
+  const handleToggle = () => {
+    if (!disabled) {
+      setIsOpen(!isOpen);
+      setActiveIndex(-1);
+    }
+  };
+
+  const handleSelect = (option: ExtendedModelOption) => {
+    if (!option.disabled) {
+      onChange?.(option.value);
+      setIsOpen(false);
+      setActiveIndex(-1);
+    }
+  };
+
+  const handleKeyDown = (e: React.KeyboardEvent) => {
+    if (disabled) {
+      return;
+    }
+
+    switch (e.key) {
+      case 'Enter':
+      case ' ':
+        e.preventDefault();
+        if (!isOpen) {
+          setIsOpen(true);
+        } else if (activeIndex >= 0) {
+          handleSelect(options[activeIndex]);
+        }
+        break;
+      case 'Escape':
+        e.preventDefault();
+        setIsOpen(false);
+        setActiveIndex(-1);
+        break;
+      case 'ArrowDown':
+        e.preventDefault();
+        if (!isOpen) {
+          setIsOpen(true);
+        } else {
+          setActiveIndex((prev) => (prev < options.length - 1 ? prev + 1 : 0));
+        }
+        break;
+      case 'ArrowUp':
+        e.preventDefault();
+        if (isOpen) {
+          setActiveIndex((prev) => (prev > 0 ? prev - 1 : options.length - 1));
+        }
+        break;
+    }
+  };
+
+  const handleClickOutside = () => {
+    setIsOpen(false);
+    setActiveIndex(-1);
+  };
+
+  useEffect(() => {
+    if (isOpen && selectRef.current) {
+      const selectRect = selectRef.current.getBoundingClientRect();
+      const viewportHeight = window.innerHeight;
+      const dropdownHeight = Math.min(400, options.length * 60);
+
+      const spaceAbove = selectRect.top;
+      const spaceBelow = viewportHeight - selectRect.bottom;
+
+      if (spaceAbove < dropdownHeight && spaceBelow > spaceAbove) {
+        setDropdownDirection('down');
+      } else {
+        setDropdownDirection('up');
+      }
+    }
+  }, [isOpen, options.length]);
+
+  useEffect(() => {
+    if (isOpen && activeIndex >= 0 && dropdownRef.current) {
+      const activeElement = dropdownRef.current.children[activeIndex] as HTMLElement;
+      if (activeElement) {
+        activeElement.scrollIntoView({
+          behavior: 'smooth',
+          block: 'nearest',
+        });
+      }
+    }
+  }, [isOpen, activeIndex]);
+
+  return (
+    <ClickOutside onOutsideClick={handleClickOutside}>
+      <div
+        ref={selectRef}
+        className={cls(
+          styles.mention_select,
+          styles[`size_${size}`],
+          {
+            [styles.disabled]: disabled,
+            [styles.open]: isOpen,
+            [styles.dropdown_up]: dropdownDirection === 'up',
+            [styles.dropdown_down]: dropdownDirection === 'down',
+          },
+          className,
+        )}
+        onClick={handleToggle}
+        onKeyDown={handleKeyDown}
+        tabIndex={disabled ? -1 : 0}
+        role='combobox'
+        aria-expanded={isOpen}
+        aria-haspopup='listbox'
+      >
+        <div className={styles.select_trigger}>
+          <div className={styles.select_content}>
+            {selectedOption ? (
+              <div className={styles.selected_option}>
+                <span className={styles.option_label}>{selectedOption.label}</span>
+                {selectedOption.badge && (
+                  <span className={styles.option_badge} style={{ backgroundColor: selectedOption.badgeColor }}>
+                    {selectedOption.badge}
+                  </span>
+                )}
+              </div>
+            ) : (
+              <span className={styles.placeholder}>{placeholder}</span>
+            )}
+          </div>
+          <Icon
+            iconClass={getIcon('down-arrow')}
+            className={cls(styles.dropdown_arrow, {
+              [styles.open]: isOpen,
+            })}
+          />
+        </div>
+
+        {isOpen && (
+          <div ref={dropdownRef} className={styles.dropdown} role='listbox'>
+            {showThinking && onThinkingChange && (
+              <div className={styles.thinking_section}>
+                <ThinkingToggle enabled={thinkingEnabled} onChange={onThinkingChange} />
+                <div className={styles.divider} />
+              </div>
+            )}
+
+            {options.map((option, index) => (
+              <div
+                key={option.value}
+                className={cls(styles.option, {
+                  [styles.active]: index === activeIndex,
+                  [styles.selected]: option.selected || option.value === value,
+                  [styles.disabled]: option.disabled,
+                })}
+                onClick={() => handleSelect(option)}
+                role='option'
+                aria-selected={option.selected || option.value === value}
+              >
+                <div className={styles.option_main}>
+                  <div className={styles.option_header}>
+                    <div className={styles.option_title}>
+                      {option.icon && <Icon icon={option.icon} className={styles.option_icon} />}
+                      {option.iconClass && <Icon iconClass={option.iconClass} className={styles.option_icon} />}
+                      <span className={styles.option_label}>{option.label}</span>
+                      {option.badge && (
+                        <span className={styles.option_badge} style={{ backgroundColor: option.badgeColor }}>
+                          {option.badge}
+                        </span>
+                      )}
+                    </div>
+                  </div>
+
+                  {option.description && <div className={styles.option_description}>{option.description}</div>}
+
+                  {option.tags && option.tags.length > 0 && (
+                    <div className={styles.option_tags}>
+                      {option.tags.map((tag, idx) => (
+                        <span key={idx} className={styles.tag}>
+                          {tag}
+                        </span>
+                      ))}
+                    </div>
+                  )}
+                </div>
+              </div>
+            ))}
+          </div>
+        )}
+      </div>
+    </ClickOutside>
+  );
+};

package/src/browser/components/mention-input/types.ts

@@ -46,6 +46,30 @@ export interface MentionState {
 interface ModelOption {
   label: string;
   value: string;
+  icon?: string;
+  iconClass?: string;
+  tags?: string[];
+  description?: string;
+  badge?: string;
+  badgeColor?: string;
+}
+
+export interface ExtendedModelOption extends ModelOption {
+  disabled?: boolean;
+  selected?: boolean; // 由外部控制选中状态
+}
+
+export interface ExtendedModelOption {
+  label: string;
+  value: string;
+  icon?: string;
+  iconClass?: string;
+  tags?: string[];
+  features?: string[];
+  description?: string;
+  disabled?: boolean;
+  badge?: string;
+  badgeColor?: string;
 }
 
 export enum FooterButtonPosition {
@@ -57,6 +81,7 @@ export enum MentionType {
   FILE = 'file',
   FOLDER = 'folder',
   CODE = 'code',
+  RULE = 'rule',
 }
 
 interface FooterButton {
@@ -70,10 +95,14 @@ interface FooterButton {
 
 export interface FooterConfig {
   modelOptions?: ModelOption[];
+  extendedModelOptions?: ExtendedModelOption[];
   defaultModel?: string;
   buttons?: FooterButton[];
   showModelSelector?: boolean;
   disableModelSelector?: boolean;
+  showThinking?: boolean;
+  thinkingEnabled?: boolean;
+  onThinkingChange?: (enabled: boolean) => void;
 }
 
 export interface MentionInputProps {

package/src/browser/context/llm-context.service.ts

@@ -1,10 +1,10 @@
-import { DataContent } from 'ai';
-
 import { Autowired, Injectable } from '@opensumi/di';
+import { PreferenceService } from '@opensumi/ide-core-browser';
 import { AppConfig } from '@opensumi/ide-core-browser/lib/react-providers/config-provider';
+import { AINativeSettingSectionsId, IApplicationService, RulesServiceToken } from '@opensumi/ide-core-common';
 import { WithEventBus } from '@opensumi/ide-core-common/lib/event-bus/event-decorator';
 import { MarkerSeverity } from '@opensumi/ide-core-common/lib/types/markers/markers';
-import { Emitter, URI } from '@opensumi/ide-core-common/lib/utils';
+import { Emitter, OperatingSystem, URI, parseGlob } from '@opensumi/ide-core-common/lib/utils';
 import {
   EditorDocumentModelCreationEvent,
   EditorDocumentModelRemovalEvent,
@@ -15,8 +15,12 @@ import { EditorSelectionChangeEvent } from '@opensumi/ide-editor/lib/browser/typ
 import { FileType, IFileServiceClient } from '@opensumi/ide-file-service';
 import { IMarkerService } from '@opensumi/ide-markers/lib/common/types';
 import { Range } from '@opensumi/ide-monaco';
+import { ITerminalApiService } from '@opensumi/ide-terminal-next';
+import { isString, match } from '@opensumi/ide-utils';
 
 import { AttachFileContext, FileContext, LLMContextService, SerializedContext } from '../../common/llm-context';
+import { ProjectRule } from '../../common/types';
+import { RulesService } from '../rules/rules.service';
 
 @Injectable()
 export class LLMContextServiceImpl extends WithEventBus implements LLMContextService {
@@ -32,6 +36,18 @@ export class LLMContextServiceImpl extends WithEventBus implements LLMContextSer
   @Autowired(IFileServiceClient)
   protected readonly fileService: IFileServiceClient;
 
+  @Autowired(RulesServiceToken)
+  protected readonly rulesService: RulesService;
+
+  @Autowired(PreferenceService)
+  protected readonly preferenceService: PreferenceService;
+
+  @Autowired(ITerminalApiService)
+  protected readonly terminalService: ITerminalApiService;
+
+  @Autowired(IApplicationService)
+  protected readonly applicationService: IApplicationService;
+
   private isAutoCollecting = false;
 
   private contextVersion = 0;
@@ -41,11 +57,13 @@ export class LLMContextServiceImpl extends WithEventBus implements LLMContextSer
   private readonly maxViewFilesLimit = 20;
   private attachedFiles: FileContext[] = [];
   private attachedFolders: FileContext[] = [];
+  private attachedRules: ProjectRule[] = [];
   private readonly recentlyViewFiles: FileContext[] = [];
   private readonly onDidContextFilesChangeEmitter = new Emitter<{
     viewed: FileContext[];
     attached: FileContext[];
     attachedFolders: FileContext[];
+    attachedRules: ProjectRule[];
     version: number;
   }>();
   private hasUserManualReference = false;
@@ -80,6 +98,24 @@ export class LLMContextServiceImpl extends WithEventBus implements LLMContextSer
     }
   }
 
+  addRuleToContext(uri: URI): void {
+    if (!uri) {
+      return;
+    }
+
+    if (this.attachedRules.some((rule) => rule.path === uri.toString())) {
+      return;
+    }
+
+    const rule = this.rulesService.projectRules.find((rule) => rule.path === uri.toString());
+    if (!rule) {
+      return;
+    }
+
+    this.attachedRules.push(rule);
+    this.notifyContextChange();
+  }
+
   addFileToContext(uri: URI, selection?: [number, number], isManual = false): void {
     if (!uri) {
       return;
@@ -117,6 +153,7 @@ export class LLMContextServiceImpl extends WithEventBus implements LLMContextSer
     this.attachedFiles = [];
     this.attachedFolders = [];
     this.hasUserManualReference = false;
+    this.attachedRules = [];
     this.notifyContextChange();
   }
 
@@ -125,6 +162,7 @@ export class LLMContextServiceImpl extends WithEventBus implements LLMContextSer
       viewed: this.recentlyViewFiles,
       attached: this.attachedFiles,
       attachedFolders: this.attachedFolders,
+      attachedRules: this.attachedRules,
       version: this.contextVersion++,
     };
   }
@@ -143,6 +181,24 @@ export class LLMContextServiceImpl extends WithEventBus implements LLMContextSer
     this.notifyContextChange();
   }
 
+  removeFolderFromContext(uri: URI): void {
+    const targetList = this.attachedFolders;
+    const index = targetList.findIndex((folder) => folder.uri.toString() === uri.toString());
+    if (index > -1) {
+      targetList.splice(index, 1);
+    }
+    this.notifyContextChange();
+  }
+
+  removeRuleFromContext(uri: URI): void {
+    const targetList = this.attachedRules;
+    const index = targetList.findIndex((rule) => rule.path === uri.toString());
+    if (index > -1) {
+      targetList.splice(index, 1);
+    }
+    this.notifyContextChange();
+  }
+
   startAutoCollection(): void {
     if (this.isAutoCollecting) {
       return;
@@ -217,25 +273,35 @@ export class LLMContextServiceImpl extends WithEventBus implements LLMContextSer
     return {
       recentlyViewFiles: this.serializeRecentlyViewFiles(files.viewed, workspaceRoot),
       attachedFiles: this.serializeAttachedFiles(files.attached, workspaceRoot),
-      attachedFolders: await this.serializeAttachedFolders(files.attachedFolders, workspaceRoot),
+      attachedFolders: await this.serializeAttachedFolders(files.attachedFolders),
+      attachedRules: this.serializeAttachedRules(files.attachedRules),
+      globalRules: this.serializeGlobalRules(),
     };
   }
 
-  private async serializeAttachedFolders(folders: FileContext[], workspaceRoot: URI): Promise<string[]> {
+  private async serializeAttachedFolders(folders: FileContext[]): Promise<string[]> {
     // 去重
     const folderPath = Array.from(new Set(folders.map((folder) => folder.uri.toString())));
-    return Promise.all(
+    const header = 'Here are some folder(s) I manually attached to my message:';
+    const folderSections = await Promise.all(
       folderPath.map(async (folder) => {
         const folderUri = new URI(folder);
-        const root = workspaceRoot.relative(folderUri)?.toString() || '/';
-        return `\`\`\`\n${root}\n${(await this.getPartiaFolderStructure(folderUri.codeUri.fsPath))
-          .map((line) => `- ${line}`)
-          .join('\n')}\n\`\`\`\n`;
+        const absolutePath = folderUri.codeUri.fsPath;
+        const folderStructure = await this.getFormattedFolderStructure(absolutePath);
+
+        return `Folder: ${absolutePath}
+Contents of directory:
+
+${folderStructure}`;
       }),
     );
+    if (folderSections.length > 0) {
+      return [header, ...folderSections, ''];
+    }
+    return [];
   }
 
-  private async getPartiaFolderStructure(folder: string, level = 2): Promise<string[]> {
+  private async getFormattedFolderStructure(folder: string): Promise<string> {
     const result: string[] = [];
     try {
       const stat = await this.fileService.getFileStat(folder);
@@ -247,28 +313,27 @@ export class LLMContextServiceImpl extends WithEventBus implements LLMContextSer
           // 处理软链接
           const target = await this.fileService.getFileStat(child.realUri || child.uri);
           if (target) {
-            result.push(`${relativePath} -> ${target} (symbolic link)`);
+            result.push(`[link] ${relativePath} -> ${target}`);
           } else {
-            result.push(`${relativePath} (broken symbolic link)`);
+            result.push(`[link] ${relativePath} (broken)`);
           }
           continue;
         }
 
         if (child.type === FileType.Directory) {
-          result.push(`${relativePath}/`);
-          if (level > 1) {
-            const subDirStructure = await this.getPartiaFolderStructure(child.uri, level - 1);
-            result.push(...subDirStructure.map((subEntry) => `${relativePath}/${subEntry}`));
-          }
+          // 计算目录下的项目数量
+          const childStat = await this.fileService.getFileStat(child.uri);
+          const itemCount = childStat?.children?.length || 0;
+          result.push(`[dir]  ${relativePath}/ (${itemCount} items)`);
         } else if (child.type === FileType.File) {
-          result.push(relativePath);
+          result.push(`[file] ${relativePath}`);
         }
       }
     } catch {
-      return result;
+      return '';
     }
 
-    return result;
+    return result.join('\n');
   }
 
   private serializeRecentlyViewFiles(files: FileContext[], workspaceRoot: URI): string[] {
@@ -295,6 +360,7 @@ export class LLMContextServiceImpl extends WithEventBus implements LLMContextSer
         lineErrors: this.getFileErrors(file.uri),
         path: workspaceRoot.relative(file.uri)!.toString(),
         language: ref.instance.languageId!,
+        selection: file.selection,
       };
     } catch (e) {
       return null;
@@ -310,4 +376,99 @@ export class LLMContextServiceImpl extends WithEventBus implements LLMContextSer
       })
       .map((marker) => marker.message);
   }
+
+  private serializeGlobalRules(): string[] {
+    const globalRules = this.preferenceService.get<string>(AINativeSettingSectionsId.GlobalRules);
+    if (!globalRules) {
+      return [];
+    }
+
+    const platform =
+      this.applicationService.backendOS === OperatingSystem.Windows
+        ? 'windows'
+        : this.applicationService.backendOS === OperatingSystem.Linux
+        ? 'linux'
+        : 'darwin';
+    const shell = this.preferenceService.get<string>('terminal.type', 'zsh');
+    let shellName = shell;
+    if (shell === 'default') {
+      shellName = this.applicationService.backendOS === OperatingSystem.Windows ? 'cmd' : 'zsh';
+    }
+    const userInfoSection = `<user_info>
+The user's OS version is ${platform}. The absolute path of the user's workspace is ${this.appConfig.workspaceDir}. The user's shell is /bin/${shellName}.
+</user_info>`;
+
+    const rulesSection = `
+
+<rules>
+The rules section has a number of possible rules/memories/context that you should consider. In each subsection, we provide instructions about what information the subsection contains and how you should consider/follow the contents of the subsection.
+
+
+<user_specific_rule description="This is a rule set by the user that the agent must follow.">
+${globalRules}
+</user_specific_rule>
+
+</rules>`;
+
+    return [userInfoSection, rulesSection];
+  }
+
+  private findApplicableRules(attachedRules: ProjectRule[]): ProjectRule[] {
+    const otherRules = this.rulesService.projectRules.filter(
+      (rule) => !attachedRules.some((attachedRule) => attachedRule.path === rule.path),
+    );
+    const requestedByAgentRules = otherRules.filter((rule) => rule.description);
+    const alwaysApplyRules = otherRules.filter((rule) => rule.alwaysApply);
+    const requestedByFileRules = this.findFileMatchingRules(otherRules);
+
+    return [...requestedByFileRules, ...requestedByAgentRules, ...alwaysApplyRules];
+  }
+  private findFileMatchingRules(otherRules: ProjectRule[]): ProjectRule[] {
+    const requestedByFileRules = otherRules.filter((rule) => rule.globs);
+    const filePaths = this.attachedFiles.map((file) => file.uri.toString());
+    const folderPaths = this.attachedFolders.map((folder) => folder.uri.toString());
+
+    return requestedByFileRules.filter((rule) => {
+      let globs = rule.globs;
+      if (isString(globs)) {
+        globs = this.normalizeGlobs(globs.split(','));
+      } else {
+        globs = this.normalizeGlobs(globs || []);
+      }
+      const patterns = globs.map((pattern) => parseGlob(pattern));
+      return patterns.some((match) => filePaths.some((path) => match(path)) || folderPaths.some((path) => match(path)));
+    });
+  }
+  private normalizeGlobs(globs: string | string[]): string[] {
+    const globArray = isString(globs) ? globs.split(',') : globs || [];
+    return globArray.map((glob) => {
+      const p = glob.trim();
+      return p.startsWith('**') ? p : `**/${p}`;
+    });
+  }
+
+  private serializeAttachedRules(rules: ProjectRule[] = []): string[] {
+    rules = this.findApplicableRules(rules);
+    if (rules.length === 0) {
+      return [];
+    }
+
+    const header =
+      '\n<rules_context>\n\nRules are extra documentation provided by the user to help the AI understand the codebase.\nUse them if they seem useful to the users most recent query, but do not use them if they seem unrelated.\n\n';
+
+    const rulesSections = rules
+      .map((rule) => {
+        const ruleName =
+          rule.path
+            .split('/')
+            .pop()
+            ?.replace(/.md(c)?$/, '') || 'Unnamed Rule';
+        return `Rule Name: ${ruleName}\nDescription: \n${rule.description || rule.content}`;
+      })
+      .join('\n\n');
+
+    const footer = '\n</rules_context>\n';
+
+    return [header, rulesSections, footer];
+  }
 }

package/src/browser/contrib/intelligent-completions/decoration/additions-deletions.decoration.ts

@@ -1,4 +1,4 @@
-import { ICodeEditor, IModelDeltaDecoration, IRange, TrackedRangeStickiness } from '@opensumi/ide-monaco';
+import { ICodeEditor, IRange, TrackedRangeStickiness } from '@opensumi/ide-monaco';
 
 import { EnhanceDecorationsCollection } from '../../../model/enhanceDecorationsCollection';
 import { REWRITE_DECORATION_INLINE_ADD } from '../../../widget/rewrite/rewrite-widget';

package/src/browser/contrib/intelligent-completions/diff-computer.ts

@@ -267,7 +267,7 @@ export const computeMultiLineDiffChanges = (
   lineNumber: number,
   eol: string,
 ) => {
-  let rewriteDiffResult: IMultiLineDiffChangeResult[] =
+  const rewriteDiffResult: IMultiLineDiffChangeResult[] =
     rewriteDiffComputer.diff(originalContent, modifiedContent) || [];
   let multiLineDiffResult: IMultiLineDiffChangeResult[] =
     multiLineDiffComputer.diff(originalContent, modifiedContent) || [];

package/src/browser/contrib/terminal/terminal.feature.registry.ts

@@ -1,6 +1,6 @@
 import { Injectable } from '@opensumi/di';
 import { CancellationToken, Disposable } from '@opensumi/ide-core-common';
-import { IReadableStream, isReadableStream, listenGroupReadable, listenReadable } from '@opensumi/ide-utils/lib/stream';
+import { IReadableStream, isReadableStream, listenGroupReadable } from '@opensumi/ide-utils/lib/stream';
 
 import { ITerminalCommandSuggestionDesc } from '../../../common/index';
 import {

package/src/browser/index.ts

@@ -17,6 +17,7 @@ import {
   IntelligentCompletionsRegistryToken,
   MCPConfigServiceToken,
   ProblemFixRegistryToken,
+  RulesServiceToken,
   TerminalRegistryToken,
 } from '@opensumi/ide-core-common';
 import { FolderFilePreferenceProvider } from '@opensumi/ide-preferences/lib/browser/folder-file-preference-provider';
@@ -77,6 +78,8 @@ import { ListDirTool } from './mcp/tools/listDir';
 import { ReadFileTool } from './mcp/tools/readFile';
 import { RunTerminalCommandTool } from './mcp/tools/runTerminalCmd';
 import { AINativePreferencesContribution } from './preferences';
+import { RulesContribution } from './rules/rules.contribution';
+import { RulesService } from './rules/rules.service';
 import { AINativeCoreContribution, MCPServerContribution, TokenMCPServerRegistry } from './types';
 import { InlineChatFeatureRegistry } from './widget/inline-chat/inline-chat.feature.registry';
 import { InlineChatService } from './widget/inline-chat/inline-chat.service';
@@ -119,6 +122,7 @@ export class AINativeModule extends BrowserModule {
 
     // Context Service
     LlmContextContribution,
+    RulesContribution,
     {
       token: LLMContextServiceToken,
       useClass: LLMContextServiceImpl,
@@ -216,6 +220,10 @@ export class AINativeModule extends BrowserModule {
       token: MCPConfigServiceToken,
       useClass: MCPConfigService,
     },
+    {
+      token: RulesServiceToken,
+      useClass: RulesService,
+    },
     {
       token: FolderFilePreferenceProvider,
       useClass: MCPFolderPreferenceProvider,