AI Coding Assistant Lingma:Filter configurations

• Processing method: You can configure filters using regular expressions, with support for 3 modes.

  Bypass	After a regular expression is matched, data is not processed.
  Block	After a regular expression is matched, model requests are directly blocked.
  Replace	After a regular expression is matched, replace the current content with the specified configurations.

• Message notification: You can enable message notifications to push to the required message receiving platform through webhooks.

• Execution order: Executed according to the configured order.

• Regular expression limit: A maximum of 10 expressions can be added.

• Regular expression standard: Regular expression configuration follows the ECMAScript standard, supporting common flags such as i (case-insensitive), g (global match), and s (DOTALL mode).

• Regular expression configuration examples:

  Rule name	Regular expression	Replacement content	Original text	After replacement
  ID card number	(?<pre>.*)(\d{15})((\d{2})([0-9Xx]))(?<post>.*)	$<pre>***$<post>	ID card number: 330204197709022312.	ID card number: ***.
  Email	\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*	***	My email address is lin***@aliyunmail.com	My email address is ***
  Password	(.*password=)([\w\d]+)(.*)	$1***$3	{password=1213213}	{password=***}

Step 1: Develop a script

You can use the TypeScript language for script development. You can refer to the following example for code development. Procedure:

1. Download the template code repository: Click the repository address: lingma-extension-template. This template repository integrates the scaffolding needed for script development. Please carefully read the README.md file and code examples.

2. Implement the "pre-processing" interface: Implement the RequestPreHandler interface. You can refer to the Custom script API for the API. The following is an example implementation snippet of SensitiveContentFilter.ts.

   /**
    * Define the sensitive content filter. The filter implements the sensitive information preprocessing of the data input to the model
    */
   export const sensitiveContentFilter: RequestPreHandler = {
     handle: async (request: RawRequest, SDKTool: LingmaSDKTool) => {
       const dataMap = PayloadUtil.getPayloadData(request.payload);
       for (const [key, value] of dataMap.entries()) {
         if (value.includes('password')) {
           return ResultUtil.buildBlockResult('Content contains password');
         }
       }
       // If you want to perform differentiated processing for different actions, refer to the following code.
       switch (request.action) {
         case ActionEnum.COMPLETION:
           // do something
           break;
         case ActionEnum.CODE_PROBLEM_SOLVE:
           // do something
           break;
         default:
           return ResultUtil.buildNoOpsResult();
       }
       return ResultUtil.buildNoOpsResult();
     },
   };

3. Run and debug the code by running the main method to test whether the script meets your expectations. Procedure:

   Step 1

   Edit the src/index.ts file, modify the main function, and adjust the code that needs to be debugged, as shown in the following example: async function main() { const value1 = ['password=123', 'abc']; const value2 = 'hello world'; const dataMap = new Map(); dataMap.set(PayloadDataKeyEnum.SELECTED_CODE, value1); dataMap.set(PayloadDataKeyEnum.USER_INPUT, value2); const mockRequest: RawRequest = { action: ActionEnum.CODE_GENERATE_COMMENT, payload: { associatedContexts: [], data: dataMap, }, requestId: '123', }; const response = await sensitiveContentFilter.handle(mockRequest, SDKTool); console.log(response); }

   Step 2

   Open the code file that you want to debug in VS Code and set a breakpoint, select the program startup icon from the debug view, and then click the Run button.

Step 2: Compile and build the script

Compile the debugged ts file into a js file, such as compiling the SensitiveContentFilter.ts file into the SensitiveContentFilter.js file. Perform the following steps to compile and build:

1. Open the configuration file src/build.js, modify the entryPoints and outfile configuration parameters, specify the path of the ts file to be compiled and built in the entryPoints parameter, and specify the output path of the built product in outfile.

2. Execute the command node build.js in the root directory of the code repository. After successful execution, the corresponding js file will be output to the product output path specified by outfile.

Step 3: Locally test the script

Before uploading the script to the enterprise configuration backend, you can complete debugging locally to ensure that the script can be integrated with the Lingma IDE plug-in and correctly perform security filtering for completion or Q&A scenario behaviors. Procedure:

1. Copy the built js file to the /extension/local/script/ directory in the Lingma local storage path.

2. Modify the config.json file: This file is located in the /extension/local/ directory of the Lingma local storage path. Open the config.json file, find contentHandlerScripts, and add the configuration information of the script to the corresponding content. If there is no contentHandlerScripts, you can add a new array-type configuration. Refer to the following example:

   {
     "contentHandlerScripts": [
       {
         "identifier": "SensitiveContentFilter", 
         "name": "Filter sensitive content",
         "version": "1.0.0",
         "scriptPath": "~/.lingma/extension/local/script/SensitiveContentFilter.js",
         "state": "enabled",
         "bizType": "completion"
       }
     ]
   }

   The following table describes the required parameters.

   Parameter	Description
   identifier	The unique script ID.
   name	The name of the script.
   version	The version number of the script. If you want to change the script content, you must upgrade the version number. Otherwise, the script cannot take effect.
   scriptPath	The path where the script is stored. Take note of the following items: The script must be stored in the /extension/local/script/ directory of the local storage path. The js file name of the script (such as SensitiveContentFilter.js) must be consistent with the value of identifier.
   state	The script status. enabled indicates that the script is enabled, and disabled indicates that the script is disabled.
   bizType	The business scenario where the script is applied. completion indicates code completion, and chat indicates intelligent Q&A.

Step 4: Upload the script

After local debugging and verification, you can upload the script. Procedure:

1. Go to the Lingma console - Policy Management, and select the scenario for which you need to enable the security filter.

2. Select custom scripts as the required filter type.

3. Upload the built JavaScript file.

4. After you upload the file, click Save Configurations. The configuration takes effect on the plug-in side in about 5 minutes.

Custom script API

The following modes are available to process custom scripts:

• Block: Subsequent process is blocked. Once blocked, the LLM is not requested for inference and this request is interrupted.

• Filter: Sent data is changed, such as obfuscation, deletion, and replacement, and then the subsequent process continues.

• Bypass: Sent data is not processed and is returned as it is, and then the subsequent process continues.

/**
 * AI Coding Assistant pre-processing interface
 */
export interface RequestPreHandler {
  // Process the current request.
  handle: (request: RawRequest, SDKTool: LingmaSDKTool) => Promise;
}

/**
 * Define the request object, including the action that triggers the current request and the raw data to be input to the LLM.
 */
export interface RawRequest {
  // The unique identifier of the current request, which can be used to track request execution.
  action: ActionEnum;
  // The action that trigger the current request.
  payload: ContentPayload;
  // The payload that encapsulates the raw data.
  requestId: string;
}

// The value types in ContentPayload.data.
export type PayloadDataValueType = string | number | string[];
/**
 * Encapsulate the raw data that is input to the LLM.
 */
export class ContentPayload {
  // The data set to be processed. You can view the corresponding key by querying the definitions of ContextValueKeyEnum.
  data: Map;
  // The context associated with data processing.
  associatedContexts: ContextItem[];

  constructor() {
    this.data = new Map();
    this.associatedContexts = [];
  }
}

/**
 * Define keys in ContentPayload.data.
 */
export enum PayloadDataKeyEnum {
  // The code snippet selected by the user.
  SELECTED_CODE ='lingma:code',
  // The text entered by the user.
  USER_INPUT = 'lingma:text',
  // The error message.
  ERROR_MESSAGES = 'lingma:error_messages',
  // The log information on the terminal.
  TERMINAL_CONTENT = 'lingma:terminal_content',
  // The preceding code snippet of the line where the current cursor is located when the code is completed.
  PREFIX_CODE = 'lingma:code_prefix',
  // The following code snippet of the line where the current cursor is located when the code is completed.
  SUFFIX_CODE = 'lingma:code_suffix',
  // The similar code snippet.
  SIMILAR_CODE = 'lingma:similar_code',
}

/**
 * Define actions that trigger requests.
 */
export enum ActionEnum {
    // Unit testing
    GENERATE_TESTCASE           = 'GENERATE_TESTCASE',
    // Generate a comment.
    CODE_GENERATE_COMMENT       = 'CODE_GENERATE_COMMENT',
    // Interpret the code.
    EXPLAIN_CODE                = 'EXPLAIN_CODE',
    // Optimize the code.
    OPTIMIZE_CODE               = 'OPTIMIZE_CODE',
    // Start a chat. You can enter text in the chat input box.
    FREE_INPUT                  = 'FREE_INPUT',
    // Quickly fix a code issue.
    CODE_PROBLEM_SOLVE          = 'CODE_PROBLEM_SOLVE',
    // Generate an shell command.
    TERMINAL_COMMAND_GENERATION = 'TERMINAL_COMMAND_GENERATION',
    // Fix a terminal error.
    TERMINAL_EXPLAIN_FIX        = 'TERMINAL_EXPLAIN_FIX',
    // Complete the code.
    COMPLETION                  = 'COMPLETION',
}

/**
 * Return model input filter results.
 */
export class HandlerResponse {
  // The processing policy that is used to control the subsequent processing logic.
  handlePolicy: HandlePolicy;
  // The reason description.
  reason?: string;
  // When handlePolicy is set to FILTER, you must set this filtering property. The property value is the filtered data and must be consistent with the content of ContentRequest.payload.
  payload?: ContentPayload;
  constructor() {
    // Default value
    // eslint-disable-next-line @typescript-eslint/no-use-before-define
    this.handlePolicy = HandlePolicy.NO_OPS;
    this.reason = '';
    this.payload = new ContentPayload();
  }
}

/**
 * Return the available processing policies.
 */
export enum HandlePolicy {
  // Block. This policy indicates that requests are directly blocked.
  BLOCK = 'BLOCK',
  // Filter. This policy indicates that requests are intercepted and the payload content is modified.
  FILTER = 'FILTER',
  // Bypass. This policy indicates that requests are not processed.
  NO_OPS = 'NO_OPS',
}

• Processing method: You can configure filters using regular expressions, with support for only one mode, as follows:

  Bypass

  After a regular expression is matched, data is not processed.

• Message notification: You can enable message notifications to push to the required message receiving platform through webhooks.

• Execution order: Executed according to the configured order.

• Regular expression limit: A maximum of 10 expressions can be added.

• Regular expression standard: Regular expression configuration follows the ECMAScript standard, supporting common flags such as i (case-insensitive), g (global match), and s (DOTALL mode).

• Regular expression configuration examples:

  Rule name	Regular expression	Original text
  ID card number	(?<pre>.*)(\d{15})((\d{2})([0-9Xx]))(?<post>.*)	ID card number: 330204197709022312.
  Email	\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*	My email address is lin***@aliyunmail.com
  Password	(.*password=)([\w\d]+)(.*)	{password=1213213}

Step 1: Develop a script

You can use the TypeScript language for script development. You can refer to the following example for code development. Procedure:

1. Download the template code repository: Click the repository address: lingma-extension-template. This template repository integrates the scaffolding needed for script development. Please carefully read the README.md file and code examples.

2. Implement the "post-processing" interface: Implement the RequestPostHandler interface. You can refer to the Custom script API for the API. The following is an example implementation snippet of LLMChatAuditHandler.ts, which implements the function of auditing AIChat operations of Lingma and reporting the audit content to Alibaba Cloud SLS.

   import {ResultUtil} from '../common/HandlerRespUtil';
   import { JsonUtil } from '../common/JsonUtil';
   import {PayloadUtil} from '../common/PayloadUtil';
   import {Config} from '../sdk/ConfigManager';
   import {LingmaSDKTool} from '../sdk/LingmaSDKTool';
   import axios from "axios";
   import moment from "moment";
   import os from "os";
   import {
     ActionEnum, AIResponse,
     HandlePolicy,
     RawRequest,
     RequestPostHandler,
     RequestPreHandler
   } from '../sdk/RequestHandleSDK';
   
   /**
    * Configure the custom script output filter. The filter implements the processing of the request content on a remote server, such as code scanning and content audit.
    */
   export const llmResultAuditHandler: RequestPostHandler = {
     handle: async (request: RawRequest, response: AIResponse,SDKTool: LingmaSDKTool) => {
        // The name of the operator.
        let userName = SDKTool.user.name;
        // The ID of the operator.
        let userId = SDKTool.user.uid;
        // ide
        let ide = SDKTool.idePlatform;
        // ide
        let ideVersion = SDKTool.ideVersion;     
        // The operation time.
        let operationTime = moment().format("YYYY-MM-DD HH:mm:ss");
        // The IP address of the operation.
        let opeartionIp = getIpAddress();
        // The business scenario of the operation. The code completion or chat scenario is available.
        let bizType = "chat";
        // The request ID of the operation.
        let requestId = request.requestId;
        // The operation that is performed.
        let action = request.action;
        // The operation content. To avoid failed reporting caused by the excessive size of reported operation content, we recommend that you select appropriate fields based on your audit requirements. The operation content cannot exceed 16 KB in size.
        let inferredResult = response.inferredResult.text;
       
        // Report the operation content to Simple Log Service (SLS).
        // The name of the project in SLS.
        let slsProject = "xxx";
        // The name of the Logstore in SLS.
        let slsLogStore = "xxx";
        // The endpoint of the region where the SLS instance resides.
        let endPoint = "cn-hangzhou.log.aliyuncs.com";
        let slsWebTrackingUrl = `http://${slsProject}.${endPoint}/logstores/${slsLogStore}/track?APIVersion=0.6.0&request_id=${requestId}&action=${action}&biz_type=${bizType}&user_name=${userName}&user_id=${userId}&ide=${ide}&ide_version=${ideVersion}&operation_time=${operationTime}&opeartion_ip=${opeartionIp}&inferredResult=${inferredResult}`;
        axios.get(slsWebTrackingUrl).catch((error) => {
          console.error(error);
        });
   
        // Return the filtering results.
       return ResultUtil.buildPostHandlerResponse(HandlePolicy.NO_OPS, response.inferredResult,'No operations are required.');
     },
   };
   
   /**
    * Add the custom script filter to the configurations.
    * @param config. It is used to manage configurations in a unified manner and is provided by LingmaExtensionSDK.
    */
   export function modifyConfig(config: Config) {
     config.postContentHandlers.push(llmResultAuditHandler);
     return config;
   }
   
   function getIpAddress() {
     const interfaces = os.networkInterfaces();
     for (let devName in interfaces) {
       let iface = interfaces[devName];
   
       for (let i = 0; i < iface.length; i++) {
         let alias = iface[i];
         if (
           alias.family === "IPv4" &&
           alias.address !== "127.0.0.1" &&
           !alias.internal
         )
           return alias.address;
       }
     }
   
     return "No IP address found";
   }

3. Run and debug the code by running the main method to test whether the script meets your expectations. Procedure:

   Step 1

   Edit the src/index.ts file, modify the main function, and adjust the code that needs to be debugged, as shown in the following example: async function main() { const value2 = 'hello world'; const dataMap = new Map(); dataMap.set(PayloadDataKeyEnum.USER_INPUT, value2); const request: RawRequest = { action: ActionEnum.CODE_GENERATE_COMMENT, payload: { associatedContexts: [], data: dataMap, }, requestId: 'test-request-id', }; const aiResponse: AIResponse = { inferredResult: { text: 'reply hello world', }, }; const response = await llmResultAuditHandler.handle(request, aiResponse, SDKTool); console.log(response); }

   Step 2

   Open the code file that you want to debug in VS Code and set a breakpoint, select the program startup icon from the debug view, and then click the Run button.

Step 2: Compile and build the script

Compile the debugged ts file into a js file, such as compiling the LLMChatAuditHandler.ts file into the LLMChatAuditHandler.js file. Perform the following steps to compile and build:

1. Open the configuration file src/build.js, modify the entryPoints and outfile configuration parameters, specify the path of the ts file to be compiled and built in the entryPoints parameter, and specify the output path of the built product in outfile.

2. Execute the command node build.js in the root directory of the code repository. After successful execution, the corresponding js file will be output to the product output path specified by outfile.

Step 3: Locally test the script

Before uploading the script to the enterprise configuration backend, you can complete debugging locally to ensure that the script can be integrated with the Lingma IDE plug-in and correctly perform security filtering for completion or Q&A scenario behaviors. Procedure:

1. Copy the built js file to the /extension/local/script/ directory in the Lingma local storage path.

2. Modify the config.json file: This file is located in the /extension/local/ directory of the Lingma local storage path. Open the config.json file, find contentHandlerScripts, and add the configuration information of the script to the corresponding content. If there is no contentHandlerScripts, you can add a new array-type configuration. Refer to the following example:

   {
     "contentHandlerScripts": [
       {
         "identifier": "LLMChatAuditHandler", 
         "name": "AIChat audit",
         "version": "1.0.0",
         "scriptPath": "~/.lingma/extension/local/script/LLMChatAuditHandler.js",
         "state": "enabled",
         "stage":"post",
         "bizType": "completion"
       }
     ]
   }

   The following table describes the required parameters.

   Parameter	Description
   identifier	The unique script ID.
   name	The name of the script.
   version	The version number of the script. If you want to change the script content, you must upgrade the version number. Otherwise, the script cannot take effect.
   scriptPath	The path where the script is stored. Take note of the following items: The script must be stored in the /extension/local/script/ directory of the local storage path. The js file name of the script (such as LLMChatAuditHandler.js) must be consistent with the value of identifier.
   state	The script status. enabled indicates that the script is enabled, and disabled indicates that the script is disabled.
   stage	The stage where the script takes effect. post indicates model output filtering, and pre indicates model input filtering. The default value is pre (model input filtering).
   bizType	The business scenario where the script is applied. completion indicates code completion, and chat indicates intelligent Q&A.

Step 4: Upload the script

After local debugging and verification, you can upload the script. Procedure:

1. Go to the Lingma console - Policy Management, and select the scenario for which you need to enable the security filter.

2. Select custom scripts as the required filter type.

3. Upload the built JavaScript file.

4. After you upload the file, click Save Configurations. The configuration takes effect on the plug-in side in about 5 minutes.

Custom script API

Only the following mode is available to process custom scripts:

• Bypass: Sent data is not processed and is returned as it is, and then the subsequent process continues.

/**
 * AI Coding Assistant post-processing interface
 * @param request The current request sent by the user.
 * @param response Inference content returned by the LLM.
 * @param SDKTool SDK tool class. You can use this tool class to obtain information about IDE and plug-ins.
 * @returns The returned results that are processed by the model output filter.
 */
export interface RequestPostHandler {
  // The model output filtering method.
  handle: (request: RawRequest, response: AIResponse, SDKTool: LingmaSDKTool) => Promise;
}

/**
 * Define the request object, including the action that triggers the current request and the raw data to be input to the LLM.
 */
export interface RawRequest {
  // The unique identifier of the current request, which can be used to track request execution.
  action: ActionEnum;
  // The action that trigger the current request.
  payload: ContentPayload;
  // The payload that encapsulates the raw data.
  requestId: string;
}

/**
 * Define the results that are generated by model inference.
 */
export class InferredResult {
  // The text content that is generated by the LLM.
  text: string;
  constructor() {
    this.text = '';
  }
}

// The value types in ContentPayload.data.
export type PayloadDataValueType = string | number | string[];
/**
 * Encapsulate the raw data that is input to the LLM.
 */
export class ContentPayload {
  // The data set to be processed. You can view the corresponding key by querying the definitions of ContextValueKeyEnum.
  data: Map;
  // The context associated with data processing.
  associatedContexts: ContextItem[];

  constructor() {
    this.data = new Map();
    this.associatedContexts = [];
  }
}

/**
 * Define keys in ContentPayload.data.
 */
export enum PayloadDataKeyEnum {
  // The code snippet selected by the user.
  SELECTED_CODE ='lingma:code',
  // The text entered by the user.
  USER_INPUT = 'lingma:text',
  // The error message.
  ERROR_MESSAGES = 'lingma:error_messages',
  // The log information on the terminal.
  TERMINAL_CONTENT = 'lingma:terminal_content',
  // The preceding code snippet of the line where the current cursor is located when the code is completed.
  PREFIX_CODE = 'lingma:code_prefix',
  // The following code snippet of the line where the current cursor is located when the code is completed.
  SUFFIX_CODE = 'lingma:code_suffix',
  // The similar code snippet.
  SIMILAR_CODE = 'lingma:similar_code',
  // The file path of the completed code.
  FILE_PATH = 'lingma:file_path',
}

/**
 * Define actions that trigger requests.
 */
export enum ActionEnum {
    // Unit testing
    GENERATE_TESTCASE           = 'GENERATE_TESTCASE',
    // Generate a comment.
    CODE_GENERATE_COMMENT       = 'CODE_GENERATE_COMMENT',
    // Interpret the code.
    EXPLAIN_CODE                = 'EXPLAIN_CODE',
    // Optimize the code.
    OPTIMIZE_CODE               = 'OPTIMIZE_CODE',
    // Start a chat. You can enter text in the chat input box.
    FREE_INPUT                  = 'FREE_INPUT',
    // Quickly fix a code issue.
    CODE_PROBLEM_SOLVE          = 'CODE_PROBLEM_SOLVE',
    // Generate an shell command.
    TERMINAL_COMMAND_GENERATION = 'TERMINAL_COMMAND_GENERATION',
    // Fix a terminal error.
    TERMINAL_EXPLAIN_FIX        = 'TERMINAL_EXPLAIN_FIX',
    // Complete the code.
    COMPLETION                  = 'COMPLETION',
}

/**
 * Return the model output filtering results.
 */
export class PostHandlerResponse {
  // The processing policy that is used to control the subsequent processing logic.
  handlePolicy: HandlePolicy;
  // The reason description.
  reason?: string;
  // The returned results that are processed by the model output filter.
  processedResult: InferredResult;
  constructor() {
    // Default value
    this.handlePolicy = HandlePolicy.NO_OPS;
    this.reason = '';
    this.processedResult = new InferredResult();
  }
}

/**
 * Encapsulate the returned LLM results.
 */
export class AIResponse {
  // The model inference results.
  inferredResult: InferredResult;
  constructor() {
    this.inferredResult = new InferredResult();
  }
}

/**
 * Define the results that are generated by model inference.
 */
export class InferredResult {
  // The text content that is generated by the LLM.
  text: string;
  constructor() {
    this.text = '';
  }
}

/**
 * The processing policy that is used to control the subsequent processing logic (only NO_OPS is currently supported for model output filters).
 */
export enum HandlePolicy {
  // Block. This policy indicates that requests are directly blocked.
  BLOCK = 'BLOCK',
  // Filter. This policy indicates that requests are intercepted and the payload content is modified.
  FILTER = 'FILTER',
  // Bypass. This policy indicates that requests are not processed.
  NO_OPS = 'NO_OPS',
}