AIIntegration: Add TextTransform commands and prompts

Author: marker-dao

packages/devextreme/js/__internal/core/ai_integration/commands/base.test.ts

@@ -62,7 +62,7 @@ describe('BaseCommand', () => {
   });
 
   describe('constructor', () => {
-    it('stores PromptManager and RequestManager correctly', () => {
+    it('should store PromptManager and RequestManager instances', () => {
       // @ts-expect-error Access to protected property for a test
       expect(command.promptManager).toBe(promptManager);
       // @ts-expect-error Access to protected property for a test
@@ -71,7 +71,7 @@ describe('BaseCommand', () => {
   });
 
   describe('execute', () => {
-    it('getTemplateName returns value correctly', () => {
+    it('getTemplateName should return the name of the corresponding template', () => {
       const spy = jest.spyOn(command, 'getTemplateName');
 
       command.execute(params, {});
@@ -80,7 +80,7 @@ describe('BaseCommand', () => {
       expect(spy).toHaveReturnedWith('test-template-name');
     });
 
-    it('buildPromptData receives and returns correct data', () => {
+    it('buildPromptData should receive and returns correct data', () => {
       const spy = jest.spyOn(command, 'buildPromptData');
 
       command.execute(params, {});
@@ -93,7 +93,7 @@ describe('BaseCommand', () => {
       });
     });
 
-    it('parseResult receives correct value and returns expected result', async () => {
+    it('parseResult should receive correct value and return expected result', async () => {
       const spy = jest.spyOn(command, 'parseResult');
 
       command.execute(params, {});
@@ -105,14 +105,14 @@ describe('BaseCommand', () => {
       expect(spy).toHaveReturnedWith('Parsed result: AI response');
     });
 
-    it('callbacks are called correctly', async () => {
-      const callbacks = {
+    it('callbacks should be called a specified number of times', async () => {
+      const callbacks: RequestCallbacks<unknown> = {
         onComplete: jest.fn(),
         onError: jest.fn(),
         onChunk: jest.fn(),
       };
 
-      command.execute(params, callbacks as RequestCallbacks);
+      command.execute(params, callbacks);
 
       await new Promise(process.nextTick);
 
@@ -121,44 +121,46 @@ describe('BaseCommand', () => {
       expect(callbacks.onChunk).toHaveBeenCalledTimes(2);
     });
 
-    it('onComplete is called with parseResult output', async () => {
-      const callbacks = { onComplete: jest.fn() };
+    it('onComplete should be called with parseResult output', async () => {
+      const callbacks: RequestCallbacks<unknown> = { onComplete: jest.fn() };
 
-      command.execute(params, callbacks as RequestCallbacks);
+      command.execute(params, callbacks);
 
       await new Promise(process.nextTick);
 
       expect(callbacks.onComplete).toHaveBeenCalledWith('Parsed result: AI response');
     });
 
-    it('calls onError if request fails', async () => {
-      const originalSendRequest = requestManager.sendRequest;
-
-      requestManager.sendRequest = (_, callbacks) => {
-        callbacks.onError?.(new Error('Test error'));
+    describe('if request fails', () => {
+      it('should call onError ', async () => {
+        const originalSendRequest = requestManager.sendRequest;
 
-        return (): void => {};
-      };
+        requestManager.sendRequest = (_, callbacks) => {
+          callbacks.onError?.(new Error('Test error'));
 
-      try {
-        const callbacks = {
-          onError: jest.fn(),
-          onComplete: jest.fn(),
+          return (): void => {};
         };
 
-        command.execute(params, callbacks as RequestCallbacks);
+        try {
+          const callbacks: RequestCallbacks<unknown> = {
+            onError: jest.fn(),
+            onComplete: jest.fn(),
+          };
 
-        await new Promise(process.nextTick);
+          command.execute(params, callbacks);
 
-        expect(callbacks.onError).toHaveBeenCalledTimes(1);
-        expect(callbacks.onError).toHaveBeenCalledWith(new Error('Test error'));
-        expect(callbacks.onComplete).toHaveBeenCalledTimes(0);
-      } finally {
-        requestManager.sendRequest = originalSendRequest;
-      }
+          await new Promise(process.nextTick);
+
+          expect(callbacks.onError).toHaveBeenCalledTimes(1);
+          expect(callbacks.onError).toHaveBeenCalledWith(new Error('Test error'));
+          expect(callbacks.onComplete).toHaveBeenCalledTimes(0);
+        } finally {
+          requestManager.sendRequest = originalSendRequest;
+        }
+      });
     });
 
-    it('calls onChunk for each chunk and onComplete correctly', () => {
+    it('should call onChunk for each chunk and onComplete a specified number of times with expected params', () => {
       const originalSendRequest = requestManager.sendRequest;
 
       requestManager.sendRequest = (_, callbacks) => {
@@ -185,7 +187,7 @@ describe('BaseCommand', () => {
       }
     });
 
-    it('executes with undefined params without errors', async () => {
+    it('should execute with undefined params without errors', async () => {
       const sendRequestSpy = jest.spyOn(requestManager, 'sendRequest');
       const onError = jest.fn();
 
@@ -197,7 +199,7 @@ describe('BaseCommand', () => {
       expect(sendRequestSpy).toHaveBeenCalledTimes(1);
     });
 
-    it('executes with partial callbacks without errors', async () => {
+    it('should execute with partial callbacks without errors', async () => {
       const sendRequestSpy = jest.spyOn(requestManager, 'sendRequest');
       const callbacks = { onChunk: jest.fn() };
 
@@ -209,12 +211,12 @@ describe('BaseCommand', () => {
       expect(sendRequestSpy).toHaveBeenCalledTimes(1);
     });
 
-    it('executes with undefined callbacks without errors', () => {
+    it('should execute with undefined callbacks without errors', () => {
       const sendRequestSpy = jest.spyOn(requestManager, 'sendRequest');
 
       expect(command.execute(
         params,
-        (undefined as unknown as RequestCallbacks),
+        (undefined as unknown as RequestCallbacks<unknown>),
       )).not.toThrow();
 
       expect(sendRequestSpy).toHaveBeenCalledTimes(1);

packages/devextreme/js/__internal/core/ai_integration/commands/base.ts

@@ -1,28 +1,30 @@
-import type { BaseCommandResult, RequestCallbacks } from '@js/common/ai-integration';
+import type { RequestCallbacks } from '@js/common/ai-integration';
 import type { PromptData, PromptManager, PromptTemplateName } from '@ts/core/ai_integration/core/prompt_manager';
-import type { RequestManager } from '@ts/core/ai_integration/core/request_manager';
+import type { RequestManager, RequestManagerCallbacks } from '@ts/core/ai_integration/core/request_manager';
 
-export abstract class BaseCommand<TParams, TResult extends BaseCommandResult> {
+export abstract class BaseCommand<TParams, TResult> {
   constructor(
     protected promptManager: PromptManager,
     protected requestManager: RequestManager,
   ) {}
 
-  public execute(params: TParams, callbacks: RequestCallbacks): () => void {
+  public execute(params: TParams, callbacks: RequestCallbacks<TResult>): () => void {
     const templateName = this.getTemplateName();
     const data = this.buildPromptData(params);
 
     const prompt = this.promptManager.buildPrompt(templateName, data);
 
-    const abort = this.requestManager.sendRequest(prompt, {
+    const requestManagerCallbacks: RequestManagerCallbacks = {
       onChunk: (chunk) => { callbacks?.onChunk?.(chunk); },
       onComplete: (result) => {
         const finalResponse = this.parseResult(result);
 
         callbacks?.onComplete?.(finalResponse);
       },
       onError: (error) => { callbacks?.onError?.(error); },
-    });
+    };
+
+    const abort = this.requestManager.sendRequest(prompt, requestManagerCallbacks);
 
     return abort;
   }

packages/devextreme/js/__internal/core/ai_integration/commands/changeStyle.test.ts

@@ -0,0 +1,105 @@
+import {
+  beforeEach,
+  describe,
+  expect,
+  it,
+  jest,
+} from '@jest/globals';
+import type {
+  AIProvider,
+  ChangeStyleCommandParams,
+  ChangeStyleCommandResult,
+  RequestCallbacks,
+} from '@js/common/ai-integration';
+import { ChangeStyleCommand } from '@ts/core/ai_integration/commands';
+import type { PromptData } from '@ts/core/ai_integration/core/prompt_manager';
+import { PromptManager } from '@ts/core/ai_integration/core/prompt_manager';
+import { RequestManager } from '@ts/core/ai_integration/core/request_manager';
+import { Provider } from '@ts/core/ai_integration/test_utils/provider_mock';
+
+describe('ChangeStyleCommand', () => {
+  const params: ChangeStyleCommandParams = {
+    text: 'text to style change',
+    writingStyle: 'creative',
+  };
+
+  let promptManager = null as unknown as PromptManager;
+  let requestManager = null as unknown as RequestManager;
+  let command = null as unknown as ChangeStyleCommand;
+
+  beforeEach(() => {
+    const provider: AIProvider = new Provider();
+
+    requestManager = new RequestManager(provider);
+    promptManager = new PromptManager();
+
+    command = new ChangeStyleCommand(promptManager, requestManager);
+  });
+
+  describe('getTemplateName', () => {
+    it('should return the name of the corresponding template', () => {
+      // @ts-expect-error Access to protected property for a test
+      const templateName = command.getTemplateName();
+
+      expect(templateName).toBe('changeStyle');
+    });
+  });
+
+  describe('buildPromptData', () => {
+    it('should form PromptData with empty object', () => {
+      // @ts-expect-error Access to protected property for a test
+      const promptData: PromptData = command.buildPromptData(params);
+
+      expect(promptData).toEqual({
+        system: { writingStyle: params.writingStyle },
+        user: { text: params.text },
+      });
+    });
+  });
+
+  describe('parseResult', () => {
+    it('should return the string without changes', () => {
+      const response = 'Shorten text';
+      // @ts-expect-error Access to protected property for a test
+      const result = command.parseResult(response);
+
+      expect(result).toBe(response);
+    });
+  });
+
+  describe('execute', () => {
+    const callbacks: RequestCallbacks<ChangeStyleCommandResult> = { onComplete: () => {} };
+
+    it('promptManager.buildPrompt should be called with parameters containing the passed values', () => {
+      const buildPromptSpy = jest.spyOn(promptManager, 'buildPrompt');
+
+      command.execute(params, callbacks);
+
+      expect(buildPromptSpy).toHaveBeenCalledTimes(1);
+      expect(promptManager.buildPrompt).toHaveBeenCalledWith('changeStyle', {
+        system: { writingStyle: params.writingStyle },
+        user: { text: params.text },
+      });
+    });
+
+    it('promptManager.buildPrompt should should return prompt with passed values', () => {
+      jest.spyOn(promptManager, 'buildPrompt');
+
+      command.execute(params, callbacks);
+
+      expect(promptManager.buildPrompt).toHaveReturnedWith({
+        system: 'Rewrite the text provided to match the creative writing style. Ensure the rewritten text follows the grammatical rules and stylistic conventions of the specified style. Preserve the original meaning and context. Use complete sentences and a professional tone. Return answer with no markdown formatting.',
+        user: params.text,
+      });
+    });
+
+    it('should call provider.sendRequest once and return the abort function', () => {
+      const sendRequestSpy = jest.spyOn(requestManager, 'sendRequest');
+
+      const abort = command.execute(params, callbacks);
+
+      expect(typeof abort).toBe('function');
+      expect(sendRequestSpy).toHaveBeenCalledTimes(1);
+    });
+  });
+});

packages/devextreme/js/__internal/core/ai_integration/commands/changeStyle.ts

@@ -0,0 +1,23 @@
+import type { ChangeStyleCommandParams, ChangeStyleCommandResult } from '@js/common/ai-integration';
+import { BaseCommand } from '@ts/core/ai_integration/commands/base';
+import type { PromptData, PromptTemplateName } from '@ts/core/ai_integration/core/prompt_manager';
+
+export class ChangeStyleCommand extends BaseCommand<
+  ChangeStyleCommandParams,
+  ChangeStyleCommandResult
+> {
+  protected getTemplateName(): PromptTemplateName {
+    return 'changeStyle';
+  }
+
+  protected buildPromptData(params: ChangeStyleCommandParams): PromptData {
+    return {
+      system: { writingStyle: params.writingStyle },
+      user: { text: params.text },
+    };
+  }
+
+  protected parseResult(response: string): ChangeStyleCommandResult {
+    return response;
+  }
+}