Compilation management method and system based on natural language large model and medium

Abstract

The application relates to a natural language large model-based compilation management method, system and medium, the method comprising receiving a natural language compilation instruction input by a user; identifying the semantic of the compilation instruction through a natural language large model and determining a corresponding compilation operation type; based on the compilation operation type, calling a corresponding compilation management tool to interact with a Jenkins service; and executing a compilation operation and returning a compilation result to the user. The application realizes intelligent interaction of compilation management through a natural language large model, can significantly simplify the operation process of a developer, improve the compilation management efficiency, and reduce the occurrence of human errors.

Description

Technical Field

[0001] This invention relates to the field of compiler management technology, and in particular to a compiler management method, system and medium based on a large natural language model. Background Technology

[0002] Compile management is a crucial aspect of software development. Traditionally, it relies on continuous integration tools like Jenkins to automate builds, tests, and deployments. Developers manually configure various parameters, including build triggers, compilation parameters, and test cases, through a graphical interface before clicking the corresponding buttons to initiate the build task. As software projects grow in scale and development teams expand, the complexity of compiler management also increases, involving the coordination and management of multiple modules, configurations, and environments. Simultaneously, the rapid development of natural language processing (NLP) technology and large language models has opened up new possibilities for human-computer interaction, making it possible to control and manage complex technical systems using natural language commands.

[0003] However, existing build management methods have many inconveniences. Developers need to manually select each Jenkins parameter and click the build button to start a build, which is cumbersome and error-prone. When checking build status, parameters, or history, users need to open the relevant pages one by one in the Jenkins interface, which is inefficient. Furthermore, due to limited server resources, users need to manually check if others are using the build service before performing a build operation to avoid resource conflicts. After compilation, users usually need to actively check the build results and log information, without timely feedback on the build status. These traditional operating modes not only increase the workload of developers but also reduce development efficiency, especially in agile development environments that require frequent build operations. Summary of the Invention

[0004] In view of the shortcomings of the prior art described above, the purpose of this invention is to provide a compilation management method, system and medium based on a large natural language model. By realizing intelligent interaction in compilation management through the large natural language model, the operation process of developers can be significantly simplified, compilation management efficiency can be improved and the occurrence of human error can be reduced.

[0005] To achieve the above objectives, the present invention adopts the following technical solution.

[0006] Firstly, the present invention provides a compilation management method based on a large natural language model, which adopts the following technical solution: Receive natural language compilation instructions from the user; The semantics of the compilation instructions are identified using a large natural language model, and the corresponding compilation operation type is determined. Based on the aforementioned compilation operation type, the corresponding compilation management tool is invoked to interact with the Jenkins service; and Perform the compilation operation and return the compilation results to the user.

[0007] Furthermore, in the above-mentioned compilation management method, identifying the semantics of the compilation instructions through a large natural language model and determining the corresponding compilation operation type includes: The keywords and semantic information in the compilation instructions are analyzed using a large natural language model. Based on the parsing results, the compilation operation type is determined to be one of three: initiating a build, terminating a build, or querying information; and Secondary user confirmation is required to verify the correctness of the model's understanding.

[0008] Furthermore, in the above-described compilation management method, when the compilation operation type is "initiate a build," the interaction between the corresponding compilation management tool and the Jenkins service, based on the compilation operation type, includes: Detect the parallelism of Jenkins tasks to determine whether compilation operations are currently supported; When the build switch is turned on, retrieve the build number of the last completed build and initiate a build; and The corresponding task number is obtained by polling and comparing the queue number and the build number.

[0009] Furthermore, in the above compilation management method, detecting the parallelism of Jenkins tasks includes: When the compilation switch is off, display the BUSY status to the user and indicate that someone is using the service and has exceeded the limit; When the compiler switch is turned on, compilation is allowed.

[0010] Furthermore, in the above-described build management method, when the build operation type is "terminate build," the interaction between the corresponding build management tool and the Jenkins service, based on the build operation type, includes: Check if a task with the specified task name is currently running; A termination operation is initiated when a task is currently executing and its task number matches; and Returns the result of the terminated operation.

[0011] Furthermore, in the above-described compilation management method, when the compilation operation type is information query, the interaction between the corresponding compilation management tool and the Jenkins service based on the compilation operation type includes: Detect the parallel execution status of Jenkins tasks; Get a list of currently running information; and The information list is traversed to obtain the parameter information of each task, including task name, task number, start time and task parameters.

[0012] Furthermore, the above-mentioned compilation management method also includes: Automatically send email notifications to users regarding compilation results and compilation process logs.

[0013] Furthermore, in the above-mentioned compilation management method, automatically sending email notifications to users regarding compilation results and compilation process logs includes: Generate email content containing compilation status information; Add the compilation process log as an attachment to the email; and Send a notification email containing the compilation results and log files to the user's email address.

[0014] Furthermore, the above-mentioned compilation management method also includes a step of recompiling based on historical build records, including: Identify user-specified historical build records; Obtain the compilation parameters of the historical build record; and The compilation operation will be restarted based on the aforementioned compilation parameters.

[0015] Furthermore, in the above-mentioned compilation management method, the natural language compilation instructions support template instruction format, and users express compilation requirements through imperative statements. The natural language big model assigns specific plug-in tools to complete the user's specific requirements based on the semantics of the user's commands.

[0016] Secondly, the present invention provides a compilation and management system based on a large natural language model, which adopts the following technical solution: The user interaction module is used to receive natural language compilation instructions input by the user. The Natural Language Large Model module is used to identify the semantics of the compilation instructions and determine the corresponding compilation operation type; The build management tool module is used to interact with the Jenkins service based on the build operation type; and The results feedback module is used to perform compilation operations and return the compilation results to the user.

[0017] Thirdly, the present invention provides a readable storage medium, which adopts the following technical solution: A readable storage medium storing computer instructions that, when executed by a processor, implement the compilation management method as described in any one of the first aspects above.

[0018] In summary, compared with the prior art, the present invention has at least one of the following beneficial technical effects: The compiler management method of this invention achieves intelligent interaction in compiler operations through a large natural language model. This allows developers to directly control the compiler process via natural language commands, eliminating the need to manually configure complex Jenkins parameters or click individual interface buttons, thus significantly simplifying the process and improving efficiency. This method can automatically identify user intent and invoke the corresponding compiler management tools, reducing the possibility of human error. Furthermore, through an automated compiler result feedback mechanism, developers can obtain timely compiler status information, which is particularly helpful in improving the overall development efficiency and collaboration experience of a team in an agile development environment. Attached Figure Description

[0019] To more clearly illustrate the technical solutions in the embodiments of this application, the accompanying drawings used in the description of the embodiments will be briefly introduced below. Obviously, the accompanying drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0020] Figure 1 An architecture diagram of a compiler management system based on a large natural language model is shown.

[0021] Figure 2 A flowchart of a compilation management method based on a large natural language model is shown.

[0022] Figure 3 A flowchart of a compilation management method based on a large natural language model is shown.

[0023] Figure 4 The flowchart for initiating a build operation is shown.

[0024] Figure 5 A flowchart for terminating the build operation is shown.

[0025] Figure 6 A flowchart of the information query operation is shown.

[0026] Figure 7 The overall flowchart of the compilation management method based on the natural language big model is shown.

[0027] Figure 8 The diagram illustrates an application scenario for a compiler management tool based on a large natural language model. Detailed Implementation

[0028] The technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, and not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application. Furthermore, it should be understood that the specific embodiments described herein are only for illustration and explanation of this application and are not intended to limit this application.

[0029] It should be noted that the order of description of the following embodiments is not intended to limit the preferred order of the embodiments of this application. Furthermore, the descriptions of each embodiment in the following embodiments have their own emphasis; for parts not described in detail in a certain embodiment, please refer to the relevant descriptions in other embodiments.

[0030] The method steps described in this embodiment of the invention can be executed in the order described in the specific implementation, or the execution order of each step can be adjusted according to actual needs, provided that the technical problem can be solved. These are not listed one by one here.

[0031] The present invention will be further described in detail below with reference to the accompanying drawings.

[0032] Reference Figure 1 The compilation and management system based on a large natural language model adopts a layered architecture design, comprising multiple functional layers and modules. From top to bottom, the system architecture includes a user interaction layer, a permission management layer, a model service layer, a central service layer, and an automated compilation management layer. The permission management layer includes an authentication module that integrates the company's domain management interface and a MongoDB database. The company's domain management interface connects to the company's unified domain service, verifying the identity and login of users based on their company domain accounts. The MongoDB database stores account information, permission information, and login records related to user identity, and performs permission authentication during platform usage.

[0033] The central service layer includes semantic and functional plugin association matching services and module code version information acquisition services. It plays a powerful supporting role in model services. Based on the semantic requirement instructions obtained from the natural language large model parsing, it matches the corresponding functional plugins. It includes components such as ORINcompile, ORINcompilestop, and ORINcompileget, which are used to complete data transmission and concrete task execution between the central service layer and the automated compilation management layer. On the right side of the central service layer, there is a code version information acquisition section for modules such as UNP, MGD, and DDM, which provides additional data support for the automated compilation management layer.

[0034] like Figure 1As shown, the automated build management service layer, located at the bottom of the system, is the core service layer connecting the internal build management logic with the external continuous integration environment. Based on the instruction parsing results output by the natural language processing model, it internally triggers corresponding build initiation, build termination, or information query processes. The push service module is responsible for proactively notifying users of build status, results, and log files via email or other messaging channels during and after the build task execution. The right side of the system features a general tools area with a Jenkins integration interface for connecting with the Jenkins continuous integration service. This interface triggers build tasks according to instructions from the internal automated build management tools, monitors the build process, and returns execution status and log data. Through the data and control flow connections between these modules, the automated build management service layer collaborates with other layers to form a complete build management system architecture.

[0035] In some implementations, the natural language processing (NLP) model-based compilation management system includes a user interaction module, a NLP model module, a compilation management tool module, and a result feedback module. The user interaction module receives natural language compilation instructions input by the user and provides an interface for user interaction with the system. The NLP model module identifies the semantics of the compilation instructions and determines the corresponding compilation operation type; this module determines the type of compilation operation required by the user through semantic parsing.

[0036] The build management tool module interacts with the Jenkins service based on the build operation type. This module, based on the identification result, calls the appropriate build management tool to establish a connection with the Jenkins service and execute the build operation. The result feedback module executes the build operation and returns the build result to the user. This module is responsible for generating the build result and sending build status information and related log files to the user via email or other means. This system architecture supports fully automated processing from user command input to build task execution and result feedback.

[0037] Reference Figure 2 The compilation management method based on a large natural language model includes a series of automated processing steps. The method begins by receiving natural language compilation instructions from the user. The system receives these instructions and performs semantic parsing. In some implementations, the user expresses compilation requirements through imperative statements, and the large natural language model assigns specific plug-in tools to fulfill the user's specific requirements based on the semantics of the user's commands.

[0038] like Figure 2As shown, this method uses a large natural language model to identify the semantics of compilation instructions and determine the corresponding compilation operation type. The large natural language model analyzes the user's instructions to determine the type of compilation operation required by the user. After identification, the system selects the appropriate plug-in tool to process the user's request based on the identification results. This method includes a secondary user confirmation step, where the system displays the user's understood instruction content for confirmation, determining whether the model's understanding is correct.

[0039] In some implementations, if the model misunderstands the code, the process returns to the user input step, allowing the user to re-enter or correct the command. If the model understands the code correctly, the method, based on the compilation operation type, calls the appropriate compilation management tool to interact with the Jenkins service. The system executes the corresponding compilation management operation and generates the result. The method performs the compilation operation and returns the compilation result to the user; the system also sends the compilation result and related log information to the user via email.

[0040] This build management method achieves zero-contact automation, replacing the traditional, cumbersome manual processes. Users no longer need to manually select Jenkins parameters and click "build" to initiate a build; instead, they can automatically complete the build task simply by inputting their build requirements. This method automatically sends email notifications to users regarding the build results and build logs, eliminating the need for users to manually monitor the build progress or actively query the results.

[0041] Reference Figure 3 The process by which a Natural Language Processing Model (NLP) identifies the semantics of compilation instructions and determines the type of compilation operation involves multiple processing stages. When a user inputs a natural language compilation instruction, the NLP performs deep semantic parsing to extract keywords and semantic information. In some implementations, the NLP leverages its language understanding capabilities acquired during training to identify semantic elements such as action words, target objects, and operation parameters in the user's instructions. The semantic parsing process involves lexical analysis, syntactic analysis, and semantic understanding of the user's input text, thereby accurately grasping the user's compilation intention.

[0042] Based on the analysis results, the Natural Language Model (NLM) determines the compilation operation type as one of three: initiate a build, terminate a build, or query information. An initiate a build operation corresponds to a user's instruction to start a new compilation task; a terminate a build operation corresponds to a user's instruction to stop an ongoing compilation task; and a query information operation corresponds to a user's instruction to obtain the current compilation status or historical compilation information. In some implementations, the NLM uses a pre-trained classification model to map user instructions to predefined compilation operation categories, ensuring the accuracy and consistency of instruction recognition.

[0043] like Figure 3As shown, after determining the compilation operation type, the system performs a second user confirmation to verify the correctness of the model's understanding. This second confirmation mechanism allows the user to verify the understanding results of the large natural language model by displaying the system's understood instructions and the type of operation to be executed. In some implementations, the system displays the parsed compilation parameters, target module, and operation type to the user; after the user confirms that everything is correct, the system continues with subsequent operations. If the user finds a deviation in the model's understanding, the user re-enters or corrects the compilation instructions, and the system re-performs semantic parsing and operation type determination.

[0044] Natural language compiler instructions support template instruction formats, allowing users to express compilation requirements through imperative statements. Template instruction formats provide a standardized way of expressing instructions; users input compiler instructions according to predefined syntax structures, improving the accuracy of instruction recognition. In some implementations, template instruction formats include components such as operation verbs, target objects, and optional parameters, allowing users to describe compilation requirements in natural language without having to memorize complex command syntax. Imperative statements allow users to express compilation intentions in an intuitive way, such as "compile module B of project A" or "query the current compilation status" in natural language.

[0045] The natural language processing (NLP) model assigns specific plugin tools to fulfill user requirements based on the semantics of user commands. The plugin tool assignment process is based on semantic parsing results and the type of compilation operation; the system automatically selects the corresponding functional plugin to execute the specific compilation management task. In some implementations, different types of compilation operations correspond to different plugin tools: initiating a build operation calls the build management plugin, terminating a build operation calls the task termination plugin, and information querying operations call the status query plugin. This automatic plugin tool assignment mechanism eliminates the need for users to manually select tools, achieving a seamless transition from natural language commands to specific compilation operations.

[0046] Reference Figure 4 When the build operation type is "Initiate Build," the build management method interacts with the Jenkins service by invoking the corresponding build management tools to achieve automated build task management. The implementation process of initiating a build operation involves several key steps to ensure that the build task starts at the appropriate time and obtains the correct task identifier. The system establishes a connection with the Jenkins service to detect the current service status and resource usage, providing users with reliable build services.

[0047] Detecting the parallelism of Jenkins tasks to determine whether compilation operations are currently supported forms a fundamental step in initiating the build process. After connecting to the Jenkins service, the system first verifies the service's normality to ensure the Jenkins server can respond to compilation requests. In some implementations, when the Jenkins server malfunctions, the system alerts the user to the server's abnormality and suggests contacting the administrator for verification. When the service is normal, the system further checks the parallelism limit of the specified task and the currently running parallel tasks to determine whether starting a new compilation task is permitted.

[0048] like Figure 4 As shown, the detection of Jenkins task parallelism includes a mechanism for determining the compile switch status. When the compile switch is off, the system displays a BUSY status to the user and indicates that someone is using the service and the limit has been exceeded. The BUSY status indicates that the number of users currently using the service exceeds the preset concurrency limit, and the system cannot accept new compile requests. In some implementations, the system displays a list of all running tasks to the user along with the BUSY status, helping the user understand the current resource usage and estimated wait time. When the compile switch is on, the system allows compile operations, and user compile requests can continue to be processed.

[0049] When the build switch is enabled, the system retrieves the last completed build number and initiates a build operation. This last completed build number provides a baseline reference for generating subsequent task numbers, ensuring that newly initiated build tasks receive the correct sequence identifier. In some implementations, the system queries the Jenkins service's build history to obtain the number of the most recently successfully completed build as the `lastnumber` parameter. Based on this build number information, the system sends a new build request to the Jenkins service, triggering the execution of the build task.

[0050] Reference Figure 4 The system obtains the corresponding task number by polling and comparing the queue number and the build number. After a successful build operation, the system obtains the queue number assigned by Jenkins, which identifies the position of the compilation task in the Jenkins task queue. The system polls and compares the queue number and last number six times to obtain the job number of the task being processed. In some implementations, the polling and comparison process involves periodically querying the task status of the Jenkins service, matching the queue number with the build number, and determining whether the compilation task has transitioned from the queue state to the execution state.

[0051] The system checks if the jobnumber is greater than 0 to determine if the build was successfully triggered and returns a job number normally. When the jobnumber is normally greater than 0, it indicates that the build was successful and a job number was returned successfully, meaning the compilation task has started correctly and obtained a valid task identifier. In some implementations, a valid job number allows users to subsequently query the compilation progress, retrieve compilation logs, or terminate the task. When the jobnumber is not normally greater than 0, it indicates that the build was successful but a job number was not returned normally, and the system provides a specific error handling mechanism.

[0052] like Figure 4 As shown, when a task number is not returned normally, the system suggests that the user contact the administrator to increase concurrency support or temporarily obtain a task number. This situation usually occurs when the Jenkins service's concurrency processing capacity reaches its limit; although the compilation task has been successfully triggered, the system cannot immediately assign a valid task number. In some implementations, the system provides the user with detailed error information and suggested solutions, including contacting the system administrator to adjust the Jenkins service's concurrency configuration, or obtaining a task number through a temporary mechanism to continue subsequent compilation management operations. When an abnormal request parameter occurs during the build process, the system prompts the user to adjust the parameters and re-initiate the compilation request.

[0053] Reference Figure 5 When the build operation type is "Terminate Build," the build management method interacts with the Jenkins service by invoking the corresponding build management tools to achieve precise control and management of the ongoing build tasks. The implementation process for terminating a build operation includes key steps such as task status detection, task number verification, and termination operation execution, ensuring that users can safely and effectively stop unnecessary build tasks. The system obtains the current task execution status and executes the corresponding termination operation through interaction with the Jenkins service.

[0054] Checking if a task with the specified job name is currently running is the first step in terminating the build process. After connecting to the Jenkins service, the system verifies the service status to ensure that task execution information can be correctly obtained. In some implementations, when the Jenkins server malfunctions, the system notifies the user of the server's abnormal condition and suggests contacting the administrator for verification. When the service status is normal, the system checks if a task with the specified job name is currently running and returns the corresponding task number information.

[0055] like Figure 5As shown, the system uses the `flagno` parameter to determine the execution status of a specified task name. When `flagno` is True, it indicates that no task is currently executing for the specified job name, and the system informs the user that there are currently no compilation tasks that can be terminated. In some implementations, the system provides detailed status information to help the user confirm the correctness of the task name or understand the current status of the task. When `flagno` is False, it indicates that a task is running for the job name, and the system continues to perform task number matching verification to determine the specific termination target.

[0056] When a task is running and its job number matches, the system initiates a termination operation to stop the specified build task. The task number matching verification compares the currently running job number with the user-specified job number to ensure the termination operation targets the correct build task. In some implementations, when the currently running job number equals the job number, the system confirms that it has found the specific build task the user wishes to terminate and then sends a termination request to the Jenkins service. This task number matching mechanism prevents accidental termination and avoids terminating incorrect build tasks.

[0057] Reference Figure 5 The system returns the execution result of the termination operation, providing the user with detailed feedback on the operation status. When the termination operation is successfully executed, the system confirms to the user that the build was successfully terminated and the compilation task has been correctly stopped. In some implementations, a successful termination operation releases the computing resources of the Jenkins server, allowing other compilation tasks to use the corresponding system resources. When an exception occurs during the termination operation, the system provides specific error information and possible cause analysis.

[0058] like Figure 5 As shown, the build termination operation includes mechanisms for handling various exceptions. When a build termination exception occurs, the system indicates that the specified jobnumber does not exist. This may be because the task has already been terminated by the administrator from the Jenkins platform. In some implementations, the system explains to the user that the task may have been terminated by other means, suggesting that the user check the current task status to confirm the actual situation of the build task. When the currently running jobnumber is not equal to the jobnumber, the system indicates that a task is being executed for the specified jobname but is not the jobnumber specified by the user, helping the user identify the job number mismatch.

[0059] The exception handling mechanism for terminating build operations provides comprehensive error diagnosis and user guidance. Through detailed status checks and error classification, the system helps users understand the specific reasons for the termination operation failure. In some implementations, the system suggests that users re-query the current compilation task status, confirm the correct task number, and then re-initiate the termination request. The exception handling mechanism ensures the reliability of the terminated build operation, providing accurate operational feedback and error diagnosis even in complex multi-task concurrent environments.

[0060] Reference Figure 6 When the compilation operation type is information query, the compilation management method interacts with the Jenkins service by calling the corresponding compilation management tools to obtain a comprehensive understanding of the current compilation task status and historical compilation information. The information query operation process includes key steps such as service connection verification, module parameter verification, task status detection, and information extraction, providing users with detailed compilation task information and system status feedback. The system obtains real-time task execution status and related parameter information through interaction with the Jenkins service.

[0061] The information query operation first establishes a connection with the Jenkins service and verifies the service status. After connecting to the Jenkins service, the system checks the server's response status to ensure that task information can be correctly obtained. In some implementations, when the Jenkins server malfunctions, the system notifies the user of the server's abnormal condition and suggests contacting the administrator for verification. When the service status is normal, the system continues to perform subsequent information query operations to ensure that the user can obtain accurate task status information.

[0062] like Figure 6 As shown, the system supports multi-module tasks and verifies whether a specified module is in the task parameter `repo` list. When the jobname is a multi-module task but the specified module is not in the task parameter `repo` list, the system prompts the user that the module is not a registered module task and suggests checking the requirements. The multi-module task support mechanism allows users to query the compilation status of a specific module, while the module verification function ensures that the query request is for a valid module configuration. In some implementations, the system maintains a `repo` list containing all registered modules, and verifies the validity of the module query request by comparing the user-specified module name with the entries in the `repo` list.

[0063] Detecting the concurrent execution of Jenkins tasks forms the core function of the information query operation. The system retrieves information on all currently running build tasks by querying the task execution status of the Jenkins service. In some implementations, the system sends a status query request to the Jenkins service to obtain status information containing all active tasks. The process of detecting concurrent execution involves a comprehensive scan of the Jenkins task queue and execution queue to ensure complete acquisition of task execution status.

[0064] Reference Figure 6 The system retrieves a list of running tasks to provide detailed status information for the current build task. This retrieval process involves detecting the parallel execution of Jenkins tasks and generating a listrun list containing all active tasks. In some implementations, the listrun list includes basic identification information for each executing task, providing a data foundation for subsequent detailed information extraction. The system determines whether a task is currently running by checking if the listrun length is greater than 0.

[0065] like Figure 6 As shown, when the length of `listrun` is not greater than 0, the system determines that the service is idle and no corresponding task is being executed. An idle state indicates that the Jenkins server currently has no build tasks being processed, and all computing resources are available. In some implementations, the system provides feedback to the user that there are currently no running tasks, helping the user understand the server's resource usage and the overall status of the build tasks. When the length of `listrun` is greater than 0, the system confirms that there are running tasks and continues with the detailed information extraction operation.

[0066] The system iterates through the information list to obtain parameter information for each task, including detailed information such as task name, task number, start time, and task parameters. While iterating through all currently executing tasks using `listrun`, the system obtains a complete set of parameter information for each task. In some implementations, the task name (`jobname`) identifies the project or module name of the compilation task, the task number (`jobnumber`) provides a unique identifier for the task, the start time (`jobstartTime`) records the task's start timestamp, and the task parameters (`jobparameter`) contain the specific configuration information for the compilation task.

[0067] Reference Figure 6The system converts the acquired timestamp into a `jobstartTime` to format and display the task start time. The timestamp conversion function transforms the raw timestamp data returned by the Jenkins service into a user-friendly time format, making it easier for users to understand the task's start time and execution duration. In some implementations, the system converts Unix timestamps or other time data into a standard date and time format, including year, month, day, hour, minute, and second information. The timestamp conversion function ensures that users can accurately understand the time information of the compilation task, supporting decisions regarding task scheduling and resource planning.

[0068] The parameter information extraction function of the information query operation provides users with a comprehensive view of the compilation task status. The system constructs a complete task status report by obtaining information such as task name, task number, start time, and task parameters. In some implementations, the task parameter information includes compilation targets, build configurations, environment variables, and other relevant compilation settings, helping users understand the specific execution content of each compilation task. Detailed parameter information supports users in performing management activities such as task monitoring, problem diagnosis, and compilation optimization.

[0069] like Figure 6 As shown, the information query operation enables comprehensive status monitoring and information retrieval of the Jenkins build environment. The system provides users with real-time build task status information through a complete process of detecting parallelism, retrieving information lists, and traversing task parameters. In some implementations, the information query function allows users to understand current resource usage, task execution progress, and system load status, providing data support for build task planning and scheduling. The information query operation, together with the build initiation and build termination operations, constitutes a complete build management function system, achieving comprehensive control and monitoring of the build environment.

[0070] Furthermore, in some implementations, the compilation management method based on a large natural language model also includes the function of automatically sending email notifications to users regarding compilation results and compilation process logs. This email notification function is automatically triggered upon completion of the compilation operation, eliminating the need for users to manually check the compilation status or actively retrieve the compilation results. The system provides users with the execution status of compilation tasks and detailed process records via email, achieving a fully automated notification mechanism for compilation management.

[0071] Automatically sending email notifications to users regarding compilation results and compilation process logs includes generating email content containing compilation status information. The email content generation process collects the execution results of the compilation task, including compilation success or failure status, task number, execution time, and related status description information. In some implementations, the compilation status information covers the task's start time, end time, execution duration, and final compilation result status, providing users with a complete overview of the compilation task's execution.

[0072] This method adds the compilation process log as an attachment to the email, allowing users to obtain detailed compilation execution records. The compilation process log contains all output information, error messages, and debugging information during the compilation task execution. In some implementations, the system retrieves the complete compilation log text from the Jenkins service, organizes the log information into a readable file format, and sends it to the user as an email attachment. The log attachment feature replaces the traditional method of relying on Jenkins platform buttons to obtain log information, allowing users to directly obtain the log text to their local machine via email.

[0073] The system sends notification emails containing compilation results and log files to the user's email address, completing the automated feedback process for compilation management. The notification email sending function uses a configured email service to send the generated email content and log attachments to the user's specified email address. In some implementations, the local log retrieval function allows users to perform self-checking, sharing, and archiving operations, enabling them to obtain and process compilation log information without logging into the Jenkins platform. This email notification mechanism proactively pushes compilation results, ensuring users receive detailed execution reports and log files immediately after the compilation task is completed.

[0074] In some implementations, the compilation management method based on a large natural language model also includes a recompiling step based on historical build records. This feature allows users to recompile a previous build request with a single sentence, avoiding repeated descriptions of the build requirements. The historical build record recompiling function accesses the build history data of the Jenkins service to obtain the configuration information of previously executed build tasks and restarts the compilation operation based on these historical configurations. This feature simplifies the operation process for repetitive compilation tasks, eliminating the need for users to re-enter complex compilation parameters and configuration information.

[0075] Identifying user-specified historical build records forms the foundation of the recompile function. The system uses a natural language processing (NLP) model to parse the user's recompile commands and extract the identification information of historical build records. In some implementations, users describe the historical task they wish to recompile using natural language, such as "recompile yesterday's project A build" or "recompile based on build number 123." The NLP model identifies key elements in the commands, such as time information, project name, and build number, to determine the specific historical build record specified by the user. The system interacts with the Jenkins service's historical data query interface to verify the existence and accessibility of the specified historical build record.

[0076] Retrieving build parameters from historical build records provides complete configuration information for recompile operations. The system extracts all build parameters for a specified build record from the Jenkins service's build history data, including project configuration, module selection, environment variables, build options, and other relevant build settings. In some implementations, the build parameter retrieval process involves detailed parsing of historical build records to extract all configuration items and parameter values ​​used during the build. The system ensures the completeness and accuracy of the retrieved build parameters to avoid recompile failures due to missing or incorrect parameters. The historical build parameter retrieval feature allows users to reuse previously successful build configurations, reducing the workload of reconfiguration.

[0077] The system automatically reproduces historical builds by re-initiating the build operation based on compilation parameters. It uses the acquired historical compilation parameters as configuration information for the new build task and sends a build request to the Jenkins service. In some implementations, the re-initiated build operation uses the same parameter configuration as the original build, ensuring consistency in the compilation environment and build options. When re-initiating the build operation, the system follows the same process as a regular build operation, including resource status checks, task number acquisition, and execution status monitoring. After the re-compilation operation is complete, the system also provides email notification functionality, sending the re-compilation results and related log information to the user.

[0078] The build history recompile feature allows users to quickly reproduce previous build tasks using simple natural language commands. This eliminates the need for users to re-enter build parameters, enabling rapid restart of build tasks through automatic history recognition and parameter extraction. In some implementations, the recompile feature is particularly suitable for scenarios requiring repeated execution of build tasks with the same configuration, such as version rollback, problem reproduction, or configuration verification. Users can trigger complex recompile operations with a single natural language command, and the system automatically handles all technical details such as history lookup, parameter extraction, and task initiation, further automating and intelligentizing build management.

[0079] Reference Figure 7 The complete implementation flow of the compiler management method based on a large natural language model demonstrates the fully automated processing from user command input to result feedback. This method forms a complete zero-contact automated compiler management solution through the collaborative work of three core components. The system architecture includes three main modules: a user interaction window, internal automated compiler management tools, and an automatic email function carrying results and log files. These modules achieve full automation of compiler management through ordered data and control flows.

[0080] like Figure 7As shown, the Natural Language Model (NLP) receiving and recognizing user commands constitutes the initial stage of the entire compilation management process. The user interaction window module receives the natural language compilation commands input by the user and performs deep semantic parsing and command recognition through the NLP. In some implementations, this stage includes sub-steps such as command reception, semantic parsing, operation type determination, and user secondary confirmation to ensure that the system accurately understands the user's compilation needs. Through its language understanding capabilities acquired during training, the NLP converts the user's natural language expression into executable compilation operation commands, achieving intelligent conversion of human-computer interaction.

[0081] The internal automated build tool module handles the core execution functions of the build management process. This module interacts with the Jenkins service by invoking the appropriate build management tool based on the identified user command type. The internal automated build management tool comprises three main functional modules: build initiation, build termination, and information query. Each module provides specialized processing logic for specific build operation types. In some implementations, the build initiation module is responsible for detecting Jenkins task parallelism, obtaining the build number, and initiating the build operation; the build termination module is responsible for task status detection and termination; and the information query module is responsible for obtaining task status information and parameter details. This module interacts with the Jenkins service API to achieve comprehensive management functions such as triggering, monitoring, querying, and terminating build tasks.

[0082] The module that automatically sends emails with results and log files completes the result feedback stage of the compilation management process. This module automatically generates a notification email containing compilation results and log information after the compilation operation is completed. In some implementations, this module obtains the execution status and complete log information of the compilation task from the Jenkins service, generates structured email content, and adds the log file as an attachment to the email. The automatic email sending function sends a notification email containing compilation results and log files to the user's inbox, eliminating the need for the user to actively check the compilation status or log information from the Jenkins platform. This module enables proactive push notifications of compilation results and localized retrieval of log information, supporting subsequent operations such as troubleshooting, result sharing, and information archiving.

[0083] like Figure 7As shown, the three core components form a complete automated compilation management process through sequential execution and data transfer. The output of the user interaction window module serves as the input to the internal automated compilation tool module, and the execution result of the internal automated compilation tool module serves as the data source for the automated email sending module. In some implementations, the entire process achieves seamless integration from natural language commands to compilation operation execution and result notification, allowing users to complete complex compilation management tasks with a single command input. This zero-contact automated compilation management solution eliminates the manual operations in traditional compilation management, including cumbersome steps such as parameter selection, status monitoring, and result acquisition, providing developers with an efficient and convenient compilation management tool.

[0084] Reference Figure 8 The compiler management system, based on a large natural language model, supports various user scenarios and application modes in real-world work environments, providing tailored compiler management solutions for technical personnel in different roles. Through intelligent interaction mechanisms and automated processing flows, the system significantly improves the overall development efficiency and collaboration experience of teams in agile development environments. The system design considers the different work needs and operating habits of two main user groups: CI integrators and developers, providing customized functional support and workflow optimization for each user group.

[0085] like Figure 8 As shown, CI integrators perform integration and compilation operations through a large command model in version release scenarios, automating the release process. CI integrators trigger the large model's integration and compilation function by inputting natural language commands; the system automatically executes the complete compilation task and generates the build artifacts required for version release. In some implementations, CI integrators receive email notifications containing compilation results and detailed log information, allowing them to quickly determine the success status of the compilation operation. When compilation is successful, CI integrators complete the version release process based on the compilation results, deploying the build artifacts to the target environment. When compilation fails, CI integrators use a feedback refeeding mechanism to feed the large model again, providing feedback, and the system offers problem diagnosis suggestions and solution guidance.

[0086] In code debugging scenarios, developers can perform single-module compilation operations using a large instruction model, enabling rapid verification and problem localization during the development process. After completing code modifications, developers can request the large model to execute single-module compilation via natural language commands. The system compiles the specified module without compiling the entire project. In some implementations, single-module compilation shortens compilation time and reduces system resource consumption, improving development and debugging efficiency. Developers receive compilation result notifications via email. When compilation is successful, they confirm the correctness of code modifications; when compilation fails, they use log files to troubleshoot problems and adjust the code.

[0087] like Figure 8 As shown, the system's feedback refeeding mechanism allows users to feed the large model again for feedback and problem-solving when compilation fails or encounters issues. This mechanism allows users to provide compilation error messages, log content, or problem descriptions as input to the natural language processing large model. The system then provides targeted solution suggestions based on error analysis and knowledge base matching. In some implementations, the large model analyzes factors such as compilation error patterns, environment configuration issues, and code dependencies to provide users with specific problem-solving guidance and operational suggestions. This mechanism forms a closed-loop processing flow from problem discovery to solution acquisition, allowing users to obtain support for resolving compilation problems through continuous interaction.

[0088] In agile development environments, this system significantly improves overall team development efficiency and collaboration by eliminating manual steps in traditional build management. Traditional build management requires developers to manually observe existing build status, select parameters one by one, and monitor build progress, while this system achieves zero-contact automated build operations. In some implementations, team members can quickly initiate build tasks via natural language commands, and the system automatically handles all technical details such as resource scheduling, task execution, and result notification. An automated email notification mechanism ensures team members receive build results promptly, supporting rapid iterative development and issue response. Through intelligent build management and collaboration support, this system provides agile development teams with an efficient technical infrastructure, promoting the standardization and automation of development processes.

[0089] This invention also discloses a readable storage medium.

[0090] A computer-readable storage medium stores a computer program that, when executed by a processor, implements the steps of the compilation management method based on a large natural language model as described in any of the above embodiments. The computer-readable storage medium may include any entity or device capable of carrying a computer program, a recording medium, a USB flash drive, a portable hard drive, a magnetic disk, an optical disk, a computer memory, a read-only memory (ROM), a random access memory (RAM), and a software distribution medium, etc. The computer program includes computer program code. The computer program code may be in the form of source code, object code, an executable file, or some intermediate form, etc. The computer-readable storage medium may include any entity or device capable of carrying computer program code, a recording medium, a USB flash drive, a portable hard drive, a magnetic disk, an optical disk, a computer memory, a read-only memory (ROM), a random access memory (RAM), and a software distribution medium, etc.

[0091] Any process or method description in the flowchart or otherwise herein can be understood as representing a module, segment, or portion of code comprising one or more executable instructions for implementing a particular logical function or process, and the scope of the preferred embodiments of the invention includes additional implementations in which functions may be performed not in the order shown or discussed, including substantially simultaneously or in reverse order depending on the functions involved, as will be understood by those skilled in the art to which embodiments of the invention pertain.

[0092] The logic and / or steps represented in the flowchart or otherwise described herein, for example, can be considered as a sequenced list of executable instructions for implementing logical functions, and can be embodied in any computer-readable medium for use by, or in conjunction with, an instruction execution system, apparatus or device (such as a computer-based system, a system including a processing module or other system that can fetch and execute instructions from, an instruction execution system, apparatus or device).

[0093] The above embodiments are only used to illustrate the technical solutions of the present invention, and are not intended to limit it. Although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features. Such modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of the present invention.

Claims

1. A compilation management method based on a large natural language model, characterized in that, include: Receive natural language compilation instructions from the user; The semantics of the compilation instructions are identified using a large natural language model, and the corresponding compilation operation type is determined. Based on the type of compilation operation, the corresponding compilation management tool is invoked to interact with the Jenkins service; as well as Perform the compilation operation and return the compilation results to the user.

2. The compilation management method according to claim 1, characterized in that, The semantics of the compilation instructions are identified using a large natural language model, and the corresponding compilation operation types are determined, including: The keywords and semantic information in the compilation instructions are analyzed using a large natural language model. Based on the parsing results, the compilation operation type is determined to be one of three: initiating a build, terminating a build, or querying information; and Secondary user confirmation is required to verify the correctness of the model's understanding.

3. The compilation management method according to claim 2, characterized in that, When the compilation operation type is "Initiate a Build", the interaction between the corresponding compilation management tool and the Jenkins service based on the compilation operation type includes: Detect the parallelism of Jenkins tasks to determine whether compilation operations are currently supported; When the build switch is turned on, retrieve the build number of the last completed build and initiate a build; and The corresponding task number is obtained by polling and comparing the queue number and the build number.

4. The compilation management method according to claim 3, characterized in that, The detection of parallel processing of Jenkins tasks includes: When the compilation switch is off, display the BUSY status to the user and indicate that someone is using the service and has exceeded the limit; When the compiler switch is turned on, compilation is allowed.

5. The compilation management method according to claim 2, characterized in that, When the compilation operation type is "Terminate Build", the interaction between the corresponding compilation management tool and the Jenkins service based on the compilation operation type includes: Check if a task with the specified task name is currently running; A termination operation is initiated when a task is currently executing and its task number matches; and Returns the result of the terminated operation.

6. The compilation management method according to claim 2, characterized in that, When the compilation operation type is information query, the interaction between the corresponding compilation management tool and the Jenkins service based on the compilation operation type includes: Detect the parallel execution status of Jenkins tasks; Get a list of currently running information; and The information list is traversed to obtain the parameter information of each task, including task name, task number, start time and task parameters.

7. The compilation management method according to claim 1, characterized in that, Also includes: Automatically send email notifications to users regarding compilation results and compilation process logs.

8. The compilation management method according to claim 7, characterized in that, Automatically sending email notifications to users of compilation results and compilation process logs includes: Generate email content containing compilation status information; Add the compilation process log as an attachment to the email; and Send a notification email containing the compilation results and log files to the user's email address.

9. The compilation management method according to claim 1, characterized in that, It also includes a step of recompiling based on historical build records, including: Identify user-specified historical build records; Obtain the compilation parameters of the historical build record; and The compilation operation will be restarted based on the aforementioned compilation parameters.

10. The compilation management method according to claim 1, characterized in that, The natural language compilation instructions support template instruction format. Users express their compilation needs through imperative statements, and the natural language big model assigns specific plug-in tools to complete the user's specific requirements based on the semantics of the user's commands.

11. A compiler management system based on a large natural language model, characterized in that, include: The user interaction module is used to receive natural language compilation instructions input by the user. The Natural Language Large Model module is used to identify the semantics of the compilation instructions and determine the corresponding compilation operation type; The build management tool module is used to interact with the Jenkins service based on the build operation type. as well as The results feedback module is used to perform compilation operations and return the compilation results to the user.

12. A readable storage medium, characterized in that, The readable storage medium stores computer instructions that, when executed by a processor, implement the compilation management method as described in any one of claims 1-10.

Images