Method and device for automatically developing process, storage medium and electronic equipment

Abstract

The invention discloses a method and device for automatically developing a process, a storage medium and electronic equipment. The method comprises the steps that N process nodes matched with a target development task are obtained, N is an integer larger than or equal to 2, and the N process nodes correspond to multiple development sub-tasks of the target development task respectively; repeating the following steps until the target code matched with the target development task is deployed to the target development platform: obtaining an intermediate development result matched with the previous process node; according to a cue word matched with the current process node, splicing the cue word with the intermediate development result to obtain a target inquiry statement; inputting the target inquiry statement into a target language model to obtain an intermediate execution result matched with the current process node; and taking the current process node as the previous process node, and updating the next process node as the current process node. The technical problem that in the prior art, the development efficiency of an automatic development process is low is solved.

Description

Technical Field

[0001] The present application relates to the field of automated development processes, and in particular, to a method and device for automated development processes, a storage medium, and an electronic device. Background Art

[0002] After receiving software requirements, software developers need to understand the requirements, write interface documents, create code branches, implement requirements with local code, submit code and conduct code review, pass the test and deploy, etc., before they can complete all the development work of the software requirements. Many manual operations in these steps are repetitive and very time-consuming; that is, the current related technologies have the problem of low software development efficiency.

[0003] To address the above-mentioned problems, no effective solution has been proposed yet. Summary of the invention

[0004] The embodiments of the present application provide a method and apparatus for an automated development process, a storage medium, and an electronic device to at least solve the technical problem of low development efficiency of the automated development process in the current related technologies.

[0005] According to one aspect of an embodiment of the present application, a method for automating a development process is provided, including: obtaining N process nodes that match a target development task, wherein N is an integer greater than or equal to 2, and the N process nodes correspond to multiple development subtasks of the target development task respectively; repeating the following steps until a target code that matches the target development task is deployed to a target development platform: obtaining an intermediate development result that matches a previous process node; splicing a target query statement with the intermediate development result based on a prompt word that matches a current process node, wherein the target query statement is used to execute the development subtask that matches the current process node based on a task execution interface that matches the prompt word; inputting the target query statement into a target language model to obtain an intermediate execution result that matches the current process node, wherein the intermediate execution result that matches the current process node is obtained by the target language model based on the task execution interface and the intermediate development result that matches the previous process node, and the intermediate execution result is used to generate a target code that matches the target development task; taking the current process node as the previous process node, and updating the next process node to the current process node.

[0006] According to another aspect of an embodiment of the present application, there is also provided a device for automating a development process, comprising: a first acquisition unit, acquiring N process nodes matching a target development task, wherein N is an integer greater than or equal to 2, and the N process nodes correspond to a plurality of development subtasks of the target development task respectively; repeating the following steps until the target code matching the target development task is deployed to the target development platform: a second acquisition unit, acquiring an intermediate development result matching a previous process node; a splicing unit, splicing a target query statement with the intermediate development result according to a prompt word matching a current process node, wherein the target query statement is used to execute the development subtask matching the current process node based on a task execution interface matching the prompt word; an execution unit, inputting the target query statement into a target language model, obtaining an intermediate execution result matching the current process node, wherein the intermediate execution result matching the current process node is obtained by the target language model based on the task execution interface and the intermediate development result matching the previous process node, and the intermediate execution result is used to generate a target code matching the target development task; an updating unit, taking the current process node as the previous process node, and updating the next process node to the current process node.

[0007] Optionally, the above-mentioned second acquisition unit includes: a generation module, used to obtain node description information corresponding to the development subtask matching the current process node; determine at least one task step of the current development subtask and the execution logic between the task steps based on the node description information; and generate a prompt word matching the current process node based on the task steps and the execution logic of the task steps.

[0008] Optionally, the above-mentioned generation module includes: a third acquisition module, used to obtain a response result of at least one task step when at least one task step corresponding to the previous process node is executed, wherein the response result includes at least one of the following: requirement description information, text information, upload information, code information, deployment information and notification information; and use the response result of at least one task step as an intermediate development result matching the previous process node.

[0009] Optionally, the above-mentioned generation module includes: a fourth acquisition module, used to obtain an intermediate development result matching a previous process node, wherein the intermediate development result includes at least one of the following: requirement description information, text information, upload information, code information, deployment information, and notification information; splicing the prompt word matching the current process node with the intermediate development result matching the previous process node to obtain a target query statement matching the current process node.

[0010] Optionally, the above-mentioned generation module also includes a first determination module, which is used to determine at least one function method used to execute at least one task step matching the current process node based on the target query statement matching the current process node; determine the function call parameters corresponding to each of the at least one function method from the intermediate development results matching the previous process node; call at least one function method respectively according to the function call parameters corresponding to each of the at least one function method; and use the call result of at least one function method as the intermediate execution result matching the current process node.

[0011] Optionally, the first determination module includes: an editing module, used to obtain node description information corresponding to the development subtask; and edit and configure the function method corresponding to at least one task step according to the node description information.

[0012] Optionally, the first acquisition unit includes: a second determination module, which is used for, when the development subtask is an interface document writing task, the task steps of the development subtask include: reading the requirement description information, generating the interface document, and transmitting the interface document to the interface document management system; when the development subtask is a code branch creation task, the task steps of the development subtask include: reading the requirement description information, generating a branch name, and creating a code branch matching the requirement description information from the code library; when the development subtask is a code review task, the task steps of the development subtask include: reading the requirement description information, reviewing according to the requirement description information and the submitted change code, and merging the code into the test branch; when the development subtask is a test code deployment task, the development The task steps of the subtask include: reading project code information and deploying the code of the test branch to the test environment server; when the development subtask is a task of merging the main branch, the task steps of the development subtask include: reading the requirement description information, reading the project code information, and merging the code of the test branch to the main branch; when the development subtask is a task of submitting a marked version code, the task steps of the development subtask include: reading the requirement description information, reading the project code information, generating version information based on the requirement description information and the submitted changed code, and marking from the main branch; when the development subtask is a task of deploying formal code, the task steps of the development subtask include: reading version information, reading the requirement description information, and deploying the marked version code to the online environment server.

[0013] Optionally, the above-mentioned first acquisition unit includes: a trigger module, which is used to receive event notification information sent by a second event detection task pre-registered in a second task processing system matching a previous process node through a pre-registered first event detection task in a first task processing system corresponding to the current process node; and determine to trigger a development subtask corresponding to the current process node based on the event notification information.

[0014] According to another aspect of the embodiments of the present application, a computer-readable storage medium is provided, in which a computer program is stored, wherein the computer program is configured to execute the above-mentioned method of automated development process when running.

[0015] According to another aspect of the embodiments of the present application, a computer program product or a computer program is provided, the computer program product or the computer program including computer instructions, the computer instructions being stored in a computer-readable storage medium. A processor of a computer device reads the computer instructions from the computer-readable storage medium, and the processor executes the computer instructions, so that the computer device executes the method for automating the development process as described above.

[0016] According to another aspect of the embodiments of the present application, there is also provided an electronic device, including a memory and a processor, wherein the memory stores a computer program, and the processor is configured to execute the above-mentioned method of automated development process through the computer program.

[0017] In an embodiment of the present application, N process nodes matching the target development task are obtained, and the following steps are repeated until the target code matching the target development task is deployed to the target development platform: an intermediate development result matching the previous process node is obtained; then, based on the prompt word matching the current process node, the target query statement is spliced ​​with the intermediate development result, wherein the target query statement is used to execute the development subtask matching the current process node based on the task execution interface matching the prompt word, and then the target query statement is input into the target language model to obtain the intermediate execution result matching the current process node, wherein the intermediate execution result matching the current process node is obtained by the target language model based on the task execution interface and the intermediate development result matching the previous process node, and the intermediate execution result is used to generate the target code matching the target development task; the current process node is used as the previous process node, and the next process node is updated to the current process node, thereby realizing the automation of the entire process operation of software development from demand to deployment, thereby solving the technical problem of low development efficiency of the automated development process in the current related technologies. BRIEF DESCRIPTION OF THE DRAWINGS

[0018] The drawings described herein are used to provide a further understanding of the present application and constitute a part of the present application. The illustrative embodiments of the present application and their descriptions are used to explain the present application and do not constitute an improper limitation on the present application. In the drawings:

[0019] Figure 1 is a schematic diagram of an application environment of an optional method for automating development process according to an embodiment of the present application;

[0020] Figure 2is a flowchart of an optional method for automating the development process according to an embodiment of the present application;

[0021] Figure 3 is a schematic diagram of an optional method for automating the development process according to an embodiment of the present application;

[0022] Figure 4 is a schematic diagram of another optional method for automating the development process according to an embodiment of the present application;

[0023] Figure 5 is a schematic diagram of another optional method for automating the development process according to an embodiment of the present application;

[0024] Figure 6 is a schematic diagram of another optional method for automating the development process according to an embodiment of the present application;

[0025] Figure 7 is a flowchart of another optional method for automating the development process according to an embodiment of the present application;

[0026] Figure 8 is a flowchart of another optional method for automating the development process according to an embodiment of the present application;

[0027] Fig. 9 is a flowchart of another optional method for automating the development process according to an embodiment of the present application;

[0028] Fig.10 is a flowchart of another optional method for automating the development process according to an embodiment of the present application;

[0029] Fig.11 is a flowchart of another optional method for automating the development process according to an embodiment of the present application;

[0030] Fig.12 is a flowchart of another optional method for automating the development process according to an embodiment of the present application;

[0031] Fig.13 is a schematic diagram of another optional method for automating the development process according to an embodiment of the present application;

[0032] Fig.14 is a schematic diagram of the structure of an optional device for automating the development process according to an embodiment of the present application;

[0033] Fig.15 It is a schematic diagram of the structure of an optional electronic device according to an embodiment of the present application. DETAILED DESCRIPTION

[0034] In order to enable those skilled in the art to better understand the solution of the present application, the technical solution in the embodiments of the present application will be clearly and completely described below in conjunction with the drawings in the embodiments of the present application. Obviously, the described embodiments are only part of the embodiments of the present application, not all of the embodiments. Based on the embodiments in the present application, all other embodiments obtained by ordinary technicians in this field without creative work should fall within the scope of protection of the present application.

[0035] It should be noted that the terms "first", "second", etc. in the specification and claims of the present application and the above-mentioned drawings are used to distinguish similar objects, and are not necessarily used to describe a specific order or sequence. It should be understood that the data used in this way can be interchangeable where appropriate, so that the embodiments of the present application described herein can be implemented in an order other than those illustrated or described herein. In addition, the terms "including" and "having" and any of their variations are intended to cover non-exclusive inclusions, for example, a process, method, system, product or device comprising a series of steps or units is not necessarily limited to those steps or units clearly listed, but may include other steps or units that are not clearly listed or inherent to these processes, methods, products or devices.

[0036] According to one aspect of the embodiments of the present application, a method for automating a development process is provided. Optionally, as an optional implementation, the method for automating a development process can be applied to, but is not limited to, Figure 1 in the environment shown.

[0037] The server 112 executes S102 to obtain N process nodes matching the target development task, where N is an integer greater than or equal to 2, and the N process nodes correspond to multiple development subtasks of the target development task respectively; the server 112 includes a database 114 and a processing engine 116.

[0038] The server 112 repeatedly executes S104 - S110 until the target code matching the target development task is deployed to the target development platform;

[0039] S104, obtaining an intermediate development result matching the previous process node;

[0040] S106, according to the prompt word matching the current process node, the target query statement is concatenated with the intermediate development result, wherein the target query statement is used to execute the development subtask matching the current process node based on the task execution interface matching the prompt word;

[0041] S108, inputting the target query statement into the target language model to obtain an intermediate execution result matching the current process node, wherein the intermediate execution result matching the current process node is obtained by the target language model based on the task execution interface and the intermediate development result matching the previous process node, and the intermediate execution result is used to generate a target code matching the target development task;

[0042] S110, taking the current process node as the previous process node, and updating the next process node as the current process node;

[0043] The server 112 executes S112 to the terminal device 102 through the network 110 to deploy the target code to the target development platform; the terminal device 102 includes a display 108 , a processor 106 , and a memory 104 .

[0044] Optionally, in this embodiment, the terminal device may be a terminal device configured with a target client, which may include but is not limited to at least one of the following: a mobile phone (such as an Android phone, an iOS phone, etc.), a laptop, a tablet computer, a PDA, a MID (Mobile Internet Devices), a PAD, a desktop computer, a smart TV, etc. The target client may be a video client, an instant messaging client, a browser client, an education client, etc. The network may include but is not limited to: a wired network, a wireless network, wherein the wired network includes: a local area network, a metropolitan area network and a wide area network, and the wireless network includes: Bluetooth, WIFI and other networks that realize wireless communication. The server may be a single server, or a server cluster consisting of multiple servers, or a cloud server. The above is only an example, and this embodiment does not impose any limitation on this.

[0045] Optionally, as an optional implementation, as Figure 2 As shown, the above-mentioned method of automating the development process includes:

[0046] S202, obtaining N process nodes matching the target development task, where N is an integer greater than or equal to 2, and the N process nodes respectively correspond to multiple development subtasks of the target development task;

[0047] S204, repeat the following steps until the target code matching the target development task is deployed to the target development platform:

[0048] Specifically, execute S206 to obtain the intermediate development result matching the previous process node;

[0049] S208, according to the prompt word matching the current process node, the target query statement is concatenated with the intermediate development result, wherein the target query statement is used to execute the development subtask matching the current process node based on the task execution interface matching the prompt word;

[0050] S210, inputting the target query statement into the target language model to obtain an intermediate execution result matching the current process node, wherein the intermediate execution result matching the current process node is obtained by the target language model based on the task execution interface and the intermediate development result matching the previous process node, and the intermediate execution result is used to generate a target code matching the target development task;

[0051] S212, taking the current process node as the previous process node, and updating the next process node as the current process node.

[0052] In step S202, N process nodes matching the target development task are obtained. It should be noted that N is an integer greater than or equal to 2, and the N process nodes correspond to multiple development subtasks of the target development task.

[0053] As an optional implementation method, taking the software development task as an example, from proposal to development completion and final acceptance and launch, the following process nodes are included: demand analysis, interface document writing, code branch creation, coding, submission, merge review, test deployment, tag submission, platform deployment;

[0054] The above development subtasks corresponding to the above process nodes include: raising requirements in the project management system; developers understand the requirements and write interface documents; use code version management tools to pull code from the code repository and create new branches; code according to the requirements description in the local integrated development environment; write submission information and submit it to the code remote repository, merge the code into the test branch, and conduct code review; test and deploy the test branch code through the code deployment platform; after the tester passes the requirement, modify the requirement status to pass the test; after the test passes, submit the tag and version related information; and deploy the corresponding tag version code online through the code deployment platform;

[0055] S204, repeat the following steps until the target code matching the target development task is deployed to the target development platform; it should be noted that each development subtask in the present application is executed in an event-driven manner. When a certain operation is performed on the development subtask, a corresponding event is generated. When this event is received, corresponding processing is automatically performed according to the event type, thereby automatically triggering the execution of the current task after the previous task is completed, and finally deploying the target code to the target development platform to realize complete software development.

[0056] S206, obtaining an intermediate development result matching the previous process node; as an optional implementation, the process node corresponding to the requirement analysis can generate the corresponding intermediate development result, such as a requirement document, including user stories, use cases, functional requirements, non-functional requirements, etc., to help the operation of the next process node;

[0057] S208, according to the prompt word matching the current process node, the target query statement is concatenated with the intermediate development result. It should be noted that the target query statement is used to execute the development subtask matching the current process node based on the task execution interface matching the prompt word;

[0058] In some optional implementations, for example, the current process node is to deploy formal code, and the prompt word matching the deployment of formal code is: after obtaining tag information from Git according to tag: {tagId}, obtain the requirement description information of requirement ID: {pmpId}, and deploy tag: {tagId} code to the online environment server; obtain the intermediate development result obtained by executing the development subtask of the previous process node, for example, including tagId and requirement ID, and splice the prompt word with the intermediate development result to obtain the target query statement: after obtaining tag information from Git according to tagId, obtain the requirement description information of requirement ID, and deploy tagId code to the online environment server, and request the task execution interface according to the above target query statement, for example, it may include: Pmp (used to read requirement description information from the requirement management system), Deploy (used to deploy specified branch code to the server), Llm (used to generate specified text according to natural language description), Api (used to transfer interface documents to the interface document management system), Git (used for basic operations of the code library), etc., and then select the corresponding interface to execute the task of deploying formal code, without specific restrictions here.

[0059] S210, input the target query statement into the target language model to obtain an intermediate execution result that matches the current process node. It should be noted that the intermediate execution result that matches the current process node is obtained by the target language model based on the task execution interface and the intermediate development result that matches the previous process node. The intermediate execution result is used to generate a target code that matches the target development task;

[0060] Optionally, the target language model may be an LLM large language model. For example, the target query statement is "after obtaining tag information from Git according to tag: v1.0.0, obtain the requirement description information of requirement ID: 123, and deploy tag: v1.0.0 code to the online environment server", input LLM to parse and obtain relevant information, and then automatically select to call the task execution interface to obtain the intermediate execution result matching the current process node; the task execution interface may be a function method based on the function platform call; the tag and requirement ID are obtained from the intermediate development result matched at the previous process node;

[0061] For example, it is parsed to read Tag information by calling the Git method, read the requirement description information by the Pmp method, and deploy the Tag code to the online environment server by the Deploy method, thereby obtaining an intermediate execution result that matches the current process node. The above intermediate execution result can be the complete code deployed to the target development platform.

[0062] S212, the current process node is used as the previous process node, and the next process node is updated as the current process node. In the case where the formal code deployment task is not completed, the steps in S204 above, namely steps S206-S210, are repeated.

[0063] Through the above-mentioned implementation mode of the present application, N process nodes matching the target development task are obtained, and the following steps are repeated until the target code matching the target development task is deployed to the target development platform: an intermediate development result matching the previous process node is obtained; then, according to the prompt word matching the current process node, the target query statement is spliced ​​with the intermediate development result, wherein the target query statement is used to execute the development subtask matching the current process node based on the task execution interface matching the prompt word, and then the target query statement is input into the target language model to obtain the intermediate execution result matching the current process node, wherein the intermediate execution result matching the current process node is obtained by the target language model based on the task execution interface and the intermediate development result matching the previous process node, and the intermediate execution result is used to generate the target code matching the target development task; the current process node is used as the previous process node, and the next process node is updated to the current process node, thereby realizing the automation of the whole process operation of software development from demand to deployment, thereby improving development efficiency.

[0064] In an optional implementation, before obtaining the intermediate development result matching the previous process node, the method further includes:

[0065] S1, obtain the node description information corresponding to the development subtask matching the current process node;

[0066] S2, determining at least one task step of the current development subtask and the execution logic between the task steps according to the node description information;

[0067] S3, generating a prompt word matching the current process node according to the task steps and the execution logic of the task steps.

[0068] In the above steps S1-S3, node description information corresponding to the development subtask matching the current process node is obtained; at least one task step of the current development subtask and the execution logic between the task steps are determined according to the node description information; prompt words matching the current process node are generated according to the task steps and the execution logic of the task steps;

[0069] As an optional implementation, for example, the development subtask of the process node matching is design, and the node description information may be: designing an interactive interface for selecting an interface theme that the user is interested in, and the design content includes interface color and font;

[0070] Furthermore, it can be determined based on the node description information that the above development subtasks may include the following task steps: interface component interaction mode design, interface layout design, and database design; the execution logic of the above tasks may include but is not limited to linear logic and branch logic, etc.;

[0071] Optionally, the above prompt words can be components sending and receiving messages through message queues, using a frame layout to lay out the page, and the design interface is colored and the font is in Kaiti. It should be noted that the above task prompt words can also be directly generated according to the type of the main development task of the process node. For example, the basic task types include: testing, design, document writing, etc., and the task steps that match the tasks of different task types can be directly determined.

[0072] Through the above-mentioned implementation mode of the present application, node description information corresponding to the development subtask matching the current process node is obtained; at least one task step of the current development subtask and the execution logic between the task steps are determined based on the node description information; prompt words matching the current process node are generated based on the task steps and the execution logic of the task steps, and the task execution steps are determined by analyzing the prompt words, thereby realizing process development automation and improving the efficiency of process development.

[0073] In an optional implementation, obtaining an intermediate development result matching a previous process node includes:

[0074] S1, when at least one task step corresponding to the previous process node is executed, obtaining a response result of at least one task step, wherein the response result includes at least one of the following: requirement description information, text information, upload information, code information, deployment information, and notification information;

[0075] S2, taking the response result of at least one task step as the intermediate development result matching the previous process node.

[0076] As an optional implementation, in the above steps S1-S2, when at least one task step corresponding to the previous process node is executed, a response result of at least one task step is obtained. It should be noted that the response result includes at least one of the following: requirement description information, text information, upload information, code information, deployment information and notification information; the response result of at least one task step is used as an intermediate development result matching the previous process node.

[0077] The above-mentioned task steps are executed by calling the function tool. For example, by calling the API method to execute the task step of transferring the document to the interface document, the upload information in the response result is that the document has been successfully uploaded. Then, the response result of at least one task step is used as the intermediate development result matching the previous process node. For example, the specification defined by the successfully uploaded document can be used as the intermediate development result, and the tasks in the subsequent process nodes are further executed according to the defined specification. This is just an example.

[0078] Through the above implementation of the present application, when at least one task step corresponding to the previous process node is executed, the response result of at least one task step is obtained, wherein the response result includes at least one of the following: requirement description information, text information, upload information, code information, deployment information, and notification information; the response result of at least one task step is used as the intermediate development result matching the previous process node. By obtaining the parameter information of the intermediate development result of the previous process node, and then splicing it with the prompt word to execute the development subtask of the current process node, the efficiency of process development is improved.

[0079] In an optional implementation, the target query statement is obtained by concatenating the prompt word matching the current process node with the intermediate development result, including:

[0080] S1, obtaining an intermediate development result matching a previous process node, wherein the intermediate development result includes at least one of the following: requirement description information, text information, upload information, code information, deployment information, and notification information;

[0081] S2, concatenate the prompt word matching the current process node with the intermediate development result matching the previous process node to obtain the target query statement matching the current process node.

[0082] It can be understood that in the above steps S1-S2, an intermediate development result matching the previous process node is obtained, wherein the intermediate development result includes at least one of the following: requirement description information, text information, upload information, code information, deployment information and notification information; the prompt word matching the previous process node and the intermediate development result matching the current process node are concatenated to obtain a target query statement matching the current process node.

[0083] As an optional implementation method, for example, the requirement description information in the intermediate development result of the previous process node is obtained, and the requirement ID is 123. The prompt word matching the current process node is to obtain the requirement description information of the requirement ID: {pmpId}, and a branch name is generated from the large model according to the requirement description information, so as to splice the prompt word matching the current process node with the intermediate development result matching the previous process node to obtain the target query statement matching the current process node: Get the requirement description information of the requirement ID: 123, and generate a branch name from the large model according to the requirement description information.

[0084] By obtaining the intermediate development results matching the previous process node, wherein the intermediate development results include at least one of the following: requirement description information, text information, upload information, code information, deployment information, and notification information; splicing the prompt words matching the current process node with the intermediate development results matching the previous process node to obtain the target query statement matching the current process node. Then, according to the target query statement, the function method of calling the execution task step is automatically analyzed, so as to realize the automation of process development and improve the efficiency of process development.

[0085] In an optional implementation, the target query statement is input into the target language model to obtain an intermediate execution result matching the current process node, including:

[0086] S1, determining at least one function method for executing at least one task step matching the current process node according to the target query statement matching the current process node;

[0087] S2, determining function call parameters corresponding to at least one function method from the intermediate development results matching the previous process node;

[0088] S3, calling at least one function method respectively according to the function calling parameters corresponding to the at least one function method;

[0089] S4, taking the calling result of at least one function method as the intermediate execution result matching the current process node.

[0090] As an optional implementation, in the above step S1, at least one function method for executing at least one task step matching the current process node is determined according to the current process node matching the target query statement;

[0091] In some optional embodiments, for example, the current process node is a deployment node, and the task of deploying formal code is divided into the following task steps: reading Tag information, reading requirement description information, and deploying Tag version code to an online environment server; it should be noted that the task of reading Tag information is performed by calling the Git function method, reading the requirement description information through the Pmp function method, and deploying the Tag version code to the online environment server through the Deploy function method.

[0092] Further in step S2, the function call parameters corresponding to at least one function method are determined from the intermediate development results matching the previous process node. For example, the function call parameters of the Git function method are the branch name / Tag information (tagID), the function call parameters of the Pmp function method are the unique identifier pmpID of the requirement, and the function call parameters of the Deploy function method are the branch name / Tag information (tagID). The above function call parameters are determined according to the execution results of the previous process node task, which is only an example here.

[0093] In the above step S3, at least one function method is called respectively according to the function call parameters corresponding to each of the at least one function method. Optionally, as Figure 3 As shown: the information of the driving event and all the function methods are input into the large language model. Each task step calls a function method through the function call information, and the task is executed in response to the function call. Specifically, the call information includes the function name and request parameters. At the same time, the function response of the previous task can be used as the request parameter of the current task.

[0094] In the above step S4, the calling result of at least one function method is used as the intermediate execution result matching the current process node;

[0095] Optionally, by calling the function method to execute the task step, the calling result of the function method is obtained, and the calling result is used as the intermediate execution result matching the current process node. For example, the function method is called to review the change code submitted according to the requirement description information, and if the review is passed, the intermediate execution result that passes the review is obtained, and the code that passes the review is used as the target code. This is only an example.

[0096] By matching the target query statement according to the current process node, at least one function method for executing at least one task step matching the current process node is determined; from the intermediate development results matching the previous process node, the function call parameters corresponding to each of the at least one function method are determined; at least one function method is called according to the function call parameters corresponding to each of the at least one function method; the call result of at least one function method is used as the intermediate execution result matching the current process node. It is implemented to provide a detailed description of the function and the parameter information expected by the function to guide the LLM to parse and obtain relevant information, and then automatically select to call the correct function to complete the task, that is, to let the LLM convert the detailed information of the driving event into the request parameters for calling the function (returned in JSON format), call the functions in sequence and get responses.

[0097] In an optional implementation, before obtaining N process nodes matching the target development task, the method further includes:

[0098] S1, obtain the node description information corresponding to the development subtask;

[0099] S2: Edit and configure the function method corresponding to at least one task step according to the node description information.

[0100] In the above steps S1-S2, the node description information corresponding to the development subtask is obtained; according to the node description information, the function method corresponding to at least one task step is edited and configured. The above node description information may indicate the function method that needs to be called in the current development subtask. In some optional implementations, for example, the step of adding an email notification requirement to the development subtask of the current process node may be as needed in the following example. Figure 4 The Notify method is added in the management background shown. It can be understood that the function method can also be modified and deleted according to the above steps to implement editing and configuration operations, thereby improving the automation level of process development. This is just an example.

[0101] In an optional implementation, after obtaining N process nodes matching the target development task, the method further includes:

[0102] S1, when the development subtask is an interface document writing task, the task steps of the development subtask include: reading requirement description information, generating an interface document, and transmitting the interface document to an interface document management system;

[0103] S2, when the development subtask is a task of creating a code branch, the task steps of the development subtask include: reading the requirement description information, generating a branch name, and creating a code branch matching the requirement description information from the code base;

[0104] S3, when the development subtask is a code review task, the task steps of the development subtask include: reading the requirement description information, reviewing according to the requirement description information and the submitted change code, and merging the code into the test branch;

[0105] S4, when the development subtask is a test code deployment task, the task steps of the development subtask include: reading project code information and deploying the code of the test branch to the test environment server;

[0106] S5, when the development subtask is a task of merging the main branch, the task steps of the development subtask include: reading requirement description information, reading project code information, and merging the code of the test branch into the main branch;

[0107] S6, when the development subtask is a task of submitting a marked version code, the task steps of the development subtask include: reading the requirement description information, reading the project code information, generating version information according to the requirement description information and the submitted change code, and marking from the main branch;

[0108] S7, when the development subtask is a task of deploying formal code, the task steps of the development subtask include: reading version information, reading requirement description information, and deploying the marked version code to the online environment server:

[0109] As an optional implementation, the above steps are described:

[0110] Specifically, when the demander submits a demand to the demand management system Jira, the detailed information includes: Requirement type: product demand; Status: Not started; Project: xx; Development manager: xx; Testing manager: xx; Operation and maintenance manager: xx; Creation time: xx; Completion time: xx; Description: In the list of feature films displayed to non-VIP or non-logged-in users, if a feature film is of the VIP paid type, its corresponding trailer should be displayed after the feature film.

[0111] After the above requirement is created on Jira, the event raised by the requirement will be notified to the coding agent.

[0112] After the coding agent receives the event notification of the demand, it triggers the task of writing the interface document in step S1, and reads the demand information through the Pmp tool according to the split subtasks. Based on the demand information, it uses the Llm tool and combines the interface document writing specifications in the long-term memory to generate the interface document. Then, it uses the Api tool to upload the latest interface document to the Video project in the interface document management tool Yapi system.

[0113] After the interface document is updated, the coding agent will be notified of the interface document writing event.

[0114] After the coding agent receives the interface document writing event notification, it triggers step S2 to create a code branch task, and first reads the requirement information through the Pmp tool according to the split subtasks, and then uses the Llm tool based on the requirement information, combined with the branch and tag naming specifications in the long-term memory, to generate a branch name: vip_list_111, and then uses the Git tool to create the vip_list_111 branch from the test branch in the Video project on gitlab.

[0115] The developer uses the local programming environment IDE to pull the vip_list_111 branch code of the Video project from gitlab. Develop the corresponding code according to the requirement description. After the self-test is completed, push the code to gitlab. gitlab notifies the coding agent of the code push event.

[0116] After the coding agent receives the event notification of the code push, it triggers step S3 to review the code task, and first reads the requirement information through the Pmp tool according to the split subtasks, and then performs code review through the Llm tool based on the requirement description information and the submitted change code, and then uses the Git tool to merge the vip_list_111 branch code into the test branch.

[0117] After the code is merged into the test branch, the coding agent will be notified of the test branch merge event.

[0118] After receiving the test branch merge event notification, the coding agent triggers the test code deployment task in step S4, and reads the required information through the Pmp tool according to the split subtasks, and then uses the Deploy tool to deploy the test branch code of the Video project to the test environment server.

[0119] The tester conducts the test in the test environment according to the requirement description information. After the test passes, the jira status is modified to pass, and the event of passing the test is notified to the coding agent.

[0120] After the coding agent receives the event notification of passing the test, step S5 is triggered to merge the main branch task. According to the split subtasks, the required information is first read through the Pmp tool, and then the project code information is read through the Git tool. Finally, the Git tool is used to merge the test branch code of the Video project into the main branch.

[0121] After the code is merged into the main branch, the coding agent will be notified of the main branch merge event.

[0122] After the coding agent receives the event notification of the main branch merge, step S6 is triggered to submit the version code marking task (submit Tag task), and according to the split subtasks, the requirement information is first read through the Pmp tool, and then the project code information is read through the Git tool. Then, based on the requirement description information and the submitted change code, combined with the branch and Tag naming specifications in the long-term memory, the Tag information is generated through the Llm tool, and finally the Git tool is used to tag from the main branch: v1.x.xxx.

[0123] After the tag is submitted, the event submitted by the tag will be notified to the coding agent.

[0124] After the coding agent receives the event notification submitted by the Tag, step S7 is triggered to deploy the formal code task. According to the split subtasks, the Tag information is first read through the Git tool, and then the required information is read through the Pmp tool. Finally, the Tag code of the Video project is deployed to the online environment server.

[0125] The above completes the whole process of a project requirement. Specifically, this application is Figure 4 The structure diagram shown realizes the automated development process. Figure 4 The tools include function methods such as Pmp(), Llm(), Api(), Git(), Depooy(), More(), and the events include trigger events such as pmp, git, idea, test, deploy, etc.

[0126] Figure 4 The structure of the agent encoded in Figure 5 As shown, it includes event receiver, task scheduler, task executor and big model (LLM); the event receiver receives events through the http interface, and the task scheduler generates task prompt words according to the event type and submits them to the task executor for execution. The task executor is the package of the big model and executes the big model request submitted by the task orchestrator. The big model is an interface proxy for the local deployment or cloud vendor's big model interface.

[0127] It should be noted that for a certain task in the same project, the coding agent will record the prompt words and task execution results of this task. When the same or different tasks are performed later, the prompt words and task execution results of all previous tasks in the project will be used as part of the prompt words for the subsequent tasks.

[0128] In the large model field, in multiple rounds of dialogue, the model needs to remember the previous dialogue content such as Figure 4 Medium memory includes long-term memory and short-term memory to better understand the current question and answer. Short-term memory can help the model remember relevant information in the short term, thereby improving the coherence and accuracy of the large model.

[0129] Long-term memory is information that is retained for a long time. The company's internal interface document writing specifications, branch and tag naming specifications, etc. are formatted into documents, then broken down into document fragments, and finally encoded into machine-recognizable information and stored in the knowledge vector library. In this solution, the existing interface document writing specifications, branch and tag naming specifications, etc. are updated and improved, and documents such as code quality specifications can also be added for use in subtasks such as code review;

[0130] Optionally, the naming convention for code repository tags is as follows: tags must start with v, followed by three segments of numbers separated by ".", the first segment is the major version number, the second segment is the minor version number, and the third segment is the revision version number. Major version number: The major version number generally starts with 0 or 1. Generally, when a project is significantly modified, the version number is increased by 1; Minor version number: The minor version number is relative to the major version number, and generally corresponds to a local adjustment under the major version; Revision version number: Generally, it is a version released to fix bugs or minor changes.

[0131] The tag naming conventions are formatted into documents, then broken down into document fragments, and finally encoded into machine-readable information and stored in the knowledge vector library. When the intelligent coding body generates tag information tasks based on the requirement description information and the submitted change code through a large model (ChatGPT, etc.), the returned tags follow the tag naming conventions, further improving the automation level and the efficiency of the automated development process.

[0132] like Figure 6 As shown in the figure, in the indexing stage, tools such as Wiki are used to collect and organize information, create a knowledge base, load formatted documents, document fragments, and encoding information in sequence, and divide large documents into smaller fragments, such as using Figure 4 The mid-planning module is used for sub-goal decomposition to facilitate retrieval and processing; in the recall phase, it asks how to do the question, determines the relevance of the information, ensures that the information is closely related to the user query or specific context, converts the information into a machine-readable format, which may involve data encoding or using a specific data structure to obtain the encoded information, performs similar queries based on the encoded information of the question, the document fragments of the knowledge base, and the encoded information, determines the relevant document fragments, and performs desensitization processing using the LLM (large language model) to protect sensitive data. Based on the retrieval results and user feedback, the retrieval process and knowledge base are fine-tuned to improve accuracy and efficiency, and then the retrieved information is processed to generate answers or solutions.

[0133] In an optional implementation, before obtaining the intermediate development result matching the previous process node, the method further includes:

[0134] S1, in a first task processing system corresponding to a current process node, receiving event notification information sent by a second event detection task pre-registered in a second task processing system matching a previous process node through a pre-registered first event detection task;

[0135] S2, determining to trigger the development subtask corresponding to the current process node according to the event notification information.

[0136] In the above steps S1-S2, in the first task processing system corresponding to the current process node, the event notification information sent by the second event detection task pre-registered in the second task processing system matching the previous process node is received through the pre-registered first event detection task; and the development subtask corresponding to the current process node is triggered according to the event notification information.

[0137] As an optional implementation, the pre-registered first event detection task can register a hook, that is, set a callback URL (used to specify how to access resources on the network). When a specific event occurs in the system, the system will automatically send a notification to this URL. For example, the current process node is to deploy the formal code, and the first task processing system is a code deployment platform. The code deployment platform has registered a first event detection task. Specifically, it can be a registration hook. The URL when the event occurs is set in the hook. When the first event detection task receives the previous process node (for example, submitting the version code), the corresponding second task processing system sends an event notification information to the second event detection task registered in the code management platform. Specifically, it can be a formal code deployment notification issued after the submission of the version code task is completed. Then, according to the event notification information, it can be determined that the development subtask of deploying the formal code node is to deploy the main branch code to the online environment.

[0138] The following is a specific implementation method to illustrate the execution of development tasks at each process node:

[0139] Write the trigger of the interface document such as Figure 7 As shown:

[0140] First, the product creation requirements in the project management system (Jira) are assigned to developers, and the testers modify the requirement status to pass the test, triggering the requirement proposal event to the event receiver of the coding agent;

[0141] Further code the task executor in the agent to trigger the writing of interface documentation request;

[0142] The interface document management system (yapi) triggers the interface document writing event to the event receiver of the coding agent, and writes the interface document according to the needs.

[0143] The trigger for creating a code branch is as follows Figure 8As shown:

[0144] The interface document management system (yapi) triggers the interface document writing event to the event receiver of the coding agent. After the interface document is written according to the requirements, the task executor triggers the creation of a code branch request;

[0145] The code management system triggers a code branch creation event to the event receiver, creates a branch from the stable code base, merges the code into the test branch, merges the code into the main branch, submits the tag and describes the requirement content.

[0146] The trigger for merging code is as follows Fig. 9 As shown:

[0147] The local integrated development environment (IntelliJ IDEA) triggers a code push event to the event receiver. The local integrated development environment (IntelliJ IDEA) is used to submit and push the code to the code repository after the code development is completed;

[0148] The task executor triggers a code merge request, and the code management system (gitlab) triggers a test branch merge event to the event receiver, executes the creation of a branch from the stable code base, merges the code to the test branch, merges the code to the main branch, submits the tag and describes the requirement content.

[0149] The trigger for test code deployment is as follows Fig.10 As shown:

[0150] The code management system triggers the test branch merge event to the event receiver, executes the above operations of creating a branch from the stable code base, merging the code to the test branch, merging the code to the main branch, submitting the tag and describing the requirements. After completion, the task executor triggers a test code deployment request;

[0151] The code deployment platform (Jenkins) triggers the test code deployment event, deploys the test branch to the test environment, and deploys the main branch code to the online environment.

[0152] The trigger for merging the trunk branch is as follows Fig.11 As shown:

[0153] The project management system (Jira) assigns product creation requirements to developers. After the tester changes the requirement status to passed, a passed test event is triggered to the event receiver;

[0154] The task executor triggers the merge request of the trunk branch;

[0155] The code management system (gitlab) triggers the trunk branch merge event to the event receiver, creates a branch from the stable code base, merges the code to the test branch, merges the code to the main branch, submits the tag and describes the requirement content.

[0156] The trigger for submitting a tag is as follows: Fig.12 As shown:

[0157] The code management system (gitlab) triggers the trunk branch merge event to the event receiver. After the operation is completed, the task executor triggers the submission of the tag request;

[0158] The code management system (gitlab) triggers a tag submission event to the event receiver, creates a branch from the stable code base, merges the code into the test branch, merges the code into the main branch, submits the tag and describes the requirement content.

[0159] The trigger for deploying the official code is as follows Fig.13 As shown:

[0160] The code management system (gitlab) triggers the tag submission event to the event receiver. After the operation is completed, the task executor triggers the deployment of the formal code request;

[0161] The code deployment platform (Jenkins) triggers the formal code deployment event to the event receiver, executes the deployment of the test branch to the test environment, and deploys the main branch code to the online environment.

[0162] The above method uses an event-driven approach and a large model to automate the entire process of software development from requirements to deployment, assisting software developers to quickly realize software requirements, improving development efficiency and saving development costs.

[0163] It should be noted that, for the aforementioned method embodiments, for the sake of simplicity, they are all expressed as a series of action combinations, but those skilled in the art should be aware that the present application is not limited by the described order of actions, because according to the present application, certain steps can be performed in other orders or simultaneously. Secondly, those skilled in the art should also be aware that the embodiments described in the specification are all preferred embodiments, and the actions and modules involved are not necessarily required by the present application.

[0164] According to another aspect of the embodiment of the present application, there is also provided a device for implementing the automated development process of the method for automated development process. Fig.14 As shown, the device comprises:

[0165] A first acquisition unit 1402 acquires N process nodes matching the target development task, where N is an integer greater than or equal to 2, and the N process nodes correspond to multiple development subtasks of the target development task respectively;

[0166] Repeat the following steps until the target code matching the target development task is deployed to the target development platform:

[0167] The second acquisition unit 1404 acquires the intermediate development result matching the previous process node;

[0168] The splicing unit 1406 splices the prompt word matching the current process node with the intermediate development result to obtain a target query statement, wherein the target query statement is used to execute the development subtask matching the current process node based on the task execution interface matching the prompt word;

[0169] The execution unit 1408 inputs the target query statement into the target language model to obtain an intermediate execution result matching the current process node, wherein the intermediate execution result matching the current process node is obtained by the target language model based on the task execution interface and the intermediate development result matching the previous process node, and the intermediate execution result is used to generate a target code matching the target development task;

[0170] The updating unit 1410 takes the current process node as the previous process node and updates the next process node to the current process node. Optionally, the above-mentioned determination unit includes: a first determination module, which is used to traverse the multiple grid control points in sequence and perform the following steps: obtaining the first image space coordinates of the current control point among the multiple grid control points, wherein the first image space coordinates include the pixel coordinates of the current control point in the original image and the depth coordinates used to indicate the layer depth of the current control point; determining the reference offset and angle offset matching the current control point according to the first image space coordinates; determining the target offset matching the current control point according to the product of the reference offset and the angle offset; determining the second image space coordinates of the current control point according to the first image space coordinates and the target offset, wherein the second image space coordinates are used to indicate the target space position of the current control point.

[0171] Optionally, the above-mentioned second acquisition unit includes: a generation module, used to obtain node description information corresponding to the development subtask matching the current process node; determine at least one task step of the current development subtask and the execution logic between the task steps based on the node description information; and generate a prompt word matching the current process node based on the task steps and the execution logic of the task steps.

[0172] Optionally, the above-mentioned generation module includes: a third acquisition module, used to obtain a response result of at least one task step when at least one task step corresponding to the previous process node is executed, wherein the response result includes at least one of the following: requirement description information, text information, upload information, code information, deployment information and notification information; and use the response result of at least one task step as an intermediate development result matching the previous process node.

[0173] Optionally, the above-mentioned generation module includes: a fourth acquisition module, used to obtain an intermediate development result matching a previous process node, wherein the intermediate development result includes at least one of the following: requirement description information, text information, upload information, code information, deployment information, and notification information; splicing the prompt word matching the current process node with the intermediate development result matching the previous process node to obtain a target query statement matching the current process node.

[0174] Optionally, the above-mentioned generation module also includes a first determination module, which is used to determine at least one function method used to execute at least one task step matching the current process node based on the target query statement matching the current process node; determine the function call parameters corresponding to each of the at least one function method from the intermediate development results matching the previous process node; call at least one function method respectively according to the function call parameters corresponding to each of the at least one function method; and use the call result of at least one function method as the intermediate execution result matching the current process node.

[0175] Optionally, the first determination module includes: an editing module, used to obtain node description information corresponding to the development subtask; and edit and configure the function method corresponding to at least one task step according to the node description information.

[0176] Optionally, the first acquisition unit includes: a second determination module, which is used for, when the development subtask is an interface document writing task, the task steps of the development subtask include: reading the requirement description information, generating the interface document, and transmitting the interface document to the interface document management system; when the development subtask is a code branch creation task, the task steps of the development subtask include: reading the requirement description information, generating a branch name, and creating a code branch matching the requirement description information from the code library; when the development subtask is a code review task, the task steps of the development subtask include: reading the requirement description information, reviewing according to the requirement description information and the submitted change code, and merging the code into the test branch; when the development subtask is a test code deployment task, the development The task steps of the subtask include: reading project code information and deploying the code of the test branch to the test environment server; when the development subtask is a task of merging the main branch, the task steps of the development subtask include: reading the requirement description information, reading the project code information, and merging the code of the test branch to the main branch; when the development subtask is a task of submitting a marked version code, the task steps of the development subtask include: reading the requirement description information, reading the project code information, generating version information based on the requirement description information and the submitted changed code, and marking from the main branch; when the development subtask is a task of deploying formal code, the task steps of the development subtask include: reading version information, reading the requirement description information, and deploying the marked version code to the online environment server.

[0177] Optionally, the above-mentioned first acquisition unit includes: a trigger module, which is used to receive event notification information sent by a second event detection task pre-registered in a second task processing system matching a previous process node through a pre-registered first event detection task in a first task processing system corresponding to the current process node; and determine to trigger a development subtask corresponding to the current process node based on the event notification information.

[0178] According to another aspect of the embodiment of the present application, an electronic device for implementing the above-mentioned method of automated development process is also provided. The electronic device may be Figure 1 The terminal device or server shown in the figure. This embodiment is described by taking the electronic device as a mobile phone or a computer as an example. Fig.15 As shown, the electronic device includes a memory 1502 and a processor 1504. The memory 1502 stores a computer program, and the processor 1504 is configured to execute the steps in any of the above method embodiments through the computer program.

[0179] Optionally, in this embodiment, the electronic device may be located in at least one network device among a plurality of network devices of a computer network.

[0180] Optionally, in this embodiment, the processor may be configured to perform the following steps through a computer program:

[0181] S1, obtaining N process nodes matching the target development task, where N is an integer greater than or equal to 2, and the N process nodes respectively correspond to multiple development subtasks of the target development task;

[0182] S2, repeat the following steps until the target code matching the target development task is deployed to the target development platform:

[0183] Get the intermediate development results that match the previous process node;

[0184] According to the prompt word matching the current process node, the target query statement is concatenated with the intermediate development result, wherein the target query statement is used to execute the development subtask matching the current process node based on the task execution interface matching the prompt word;

[0185] Input the target query statement into the target language model to obtain an intermediate execution result that matches the current process node, wherein the intermediate execution result that matches the current process node is obtained by the target language model based on the task execution interface and the intermediate development result that matches the previous process node, and the intermediate execution result is used to generate a target code that matches the target development task;

[0186] Set the current process node as the previous process node and update the next process node as the current process node.

[0187] Alternatively, a person skilled in the art may understand that: Fig.15 The structure shown is for illustration only, and the electronic device may also be a smart phone (such as an Android phone, an iOS phone, etc.), a tablet computer, a PDA, a mobile Internet device (Mobile Internet Devices, MID), a PAD, or other terminal devices. Fig.15 The structure of the electronic device is not limited. Fig.15 More or fewer components (such as network interfaces, etc.) as shown in, or with Fig.15 Different configurations are shown.

[0188] Among them, the memory 1502 can be used to store software programs and modules, such as the program instructions / modules corresponding to the method and device for automating the development process in the embodiment of the present application. The processor 1504 executes various functional applications and data processing by running the software programs and modules stored in the memory 1502, that is, implementing the above-mentioned method for automating the development process. The memory 1502 may include a high-speed random access memory, and may also include a non-volatile memory, such as one or more magnetic storage devices, flash memory, or other non-volatile solid-state memory. In some instances, the memory 1502 may further include a memory remotely located relative to the processor 1504, and these remote memories may be connected to the terminal via a network. Examples of the above-mentioned networks include, but are not limited to, the Internet, corporate intranets, local area networks, mobile communication networks, and combinations thereof. As an example, if Fig.15 As shown, the memory 1502 may include, but is not limited to, the first acquisition unit 1402, the second acquisition unit 1404, the splicing unit 1406, the execution unit 1408, and the update unit 1410 in the device for the automated development process. In addition, other module units in the device for the automated development process may also be included but are not limited to, which will not be repeated in this example.

[0189] Optionally, the transmission device 1506 is used to receive or send data via a network. Specific examples of the above-mentioned network may include a wired network and a wireless network. In one example, the transmission device 1506 includes a network adapter (Network Interface Controller, NIC), which can be connected to other network devices and routers via a network cable so as to communicate with the Internet or a local area network. In one example, the transmission device 1506 is a radio frequency (RF) module, which is used to communicate with the Internet wirelessly.

[0190] In addition, the electronic device mentioned above further includes: a display 1508 and a connection bus 1510, which is used to connect various module components in the electronic device mentioned above.

[0191] In other embodiments, the terminal device or server may be a node in a distributed system, wherein the distributed system may be a blockchain system, and the blockchain system may be a distributed system formed by connecting the multiple nodes through network communication. The nodes may form a point-to-point network, and any form of computing device, such as a server, terminal or other electronic device, may become a node in the blockchain system by joining the point-to-point network.

[0192] According to one aspect of the present application, a computer-readable storage medium is provided, and a processor of a computer device reads the computer instruction from the computer-readable storage medium, and the processor executes the computer instruction, so that the computer device executes the method provided in the above various optional implementations;

[0193] Optionally, in this embodiment, the computer-readable storage medium may be configured to store a computer program for performing the following steps:

[0194] S1, obtaining N process nodes matching the target development task, where N is an integer greater than or equal to 2, and the N process nodes respectively correspond to multiple development subtasks of the target development task;

[0195] S2, repeat the following steps until the target code matching the target development task is deployed to the target development platform:

[0196] Get the intermediate development results that match the previous process node;

[0197] According to the prompt word matching the current process node, the target query statement is concatenated with the intermediate development result, wherein the target query statement is used to execute the development subtask matching the current process node based on the task execution interface matching the prompt word;

[0198] Input the target query statement into the target language model to obtain an intermediate execution result that matches the current process node, wherein the intermediate execution result that matches the current process node is obtained by the target language model based on the task execution interface and the intermediate development result that matches the previous process node, and the intermediate execution result is used to generate a target code that matches the target development task;

[0199] Set the current process node as the previous process node and update the next process node as the current process node.

[0200] Optionally, in the embodiments of the present application, the term "module" or "unit" refers to a computer program or a part of a computer program with a predetermined function, and works together with other related parts to achieve a predetermined goal, and can be implemented in whole or in part by using software, hardware (such as processing circuits or memories), or a combination thereof. Similarly, a processor (or multiple processors or memories) can be used to implement one or more modules or units. In addition, each module or unit can be part of an overall module or unit that includes the function of the module or unit.

[0201] Optionally, in this embodiment, a person of ordinary skill in the art may understand that all or part of the steps in the various methods of the above embodiments may be completed by instructing hardware related to the terminal device through a program, and the program may be stored in a computer-readable storage medium, and the storage medium may include: a flash drive, a read-only memory (ROM), a random access memory (RAM), a disk or an optical disk, etc.

[0202] If the integrated units in the above embodiments are implemented in the form of software functional units and sold or used as independent products, they can be stored in the above computer-readable storage medium. Based on this understanding, the technical solution of the present application, or the part that contributes to the prior art, or all or part of the technical solution can be embodied in the form of a software product, which is stored in a storage medium and includes several instructions for enabling one or more computer devices (which may be personal computers, servers, or network devices, etc.) to execute all or part of the steps of the methods described in the various embodiments of the present application.

[0203] In the above embodiments of the present application, the description of each embodiment has its own emphasis. For parts that are not described in detail in a certain embodiment, please refer to the relevant description of other embodiments.

[0204] In the several embodiments provided in the present application, it should be understood that the disclosed client can be implemented in other ways. Among them, the device embodiments described above are only schematic. For example, the division of the units is only a logical function division. There may be other division methods in actual implementation. For example, multiple units or components can be combined or integrated into another system, or some features can be ignored or not executed. Another point is that the mutual coupling or direct coupling or communication connection shown or discussed can be through some interfaces, indirect coupling or communication connection of units or modules, which can be electrical or other forms.

[0205] The units described as separate components may or may not be physically separated, and the components shown as units may or may not be physical units, that is, they may be located in one place or distributed on multiple network units. Some or all of the units may be selected according to actual needs to achieve the purpose of the solution of this embodiment.

[0206] In addition, each functional unit in each embodiment of the present application may be integrated into one processing unit, or each unit may exist physically separately, or two or more units may be integrated into one unit. The above-mentioned integrated unit may be implemented in the form of hardware or in the form of software functional units.

[0207] The above is only a preferred implementation of the present application. It should be pointed out that for ordinary technicians in this technical field, several improvements and modifications can be made without departing from the principles of the present application. These improvements and modifications should also be regarded as the scope of protection of the present application.

Claims

1. A method for automating a development process, characterized in that: include: Acquire N process nodes matching the target development task, wherein N is an integer greater than or equal to 2, and the N process nodes respectively correspond to multiple development subtasks of the target development task; Repeat the following steps until the target code matching the target development task is deployed to the target development platform: Get the intermediate development results that match the previous process node; According to the prompt word matching the current process node, the target query statement is spliced ​​with the intermediate development result, wherein the target query statement is used to execute the development subtask matching the current process node based on the task execution interface matching the prompt word; Input the target query statement into the target language model to obtain an intermediate execution result matching the current process node, wherein the intermediate execution result matching the current process node is obtained by the target language model based on the task execution interface and the intermediate development result matching the previous process node, and the intermediate execution result is used to generate the target code matching the target development task; The current process node is used as the previous process node, and the next process node is updated as the current process node.

2. The method according to claim 1, characterized in that Before obtaining the intermediate development result matching the previous process node, the process further includes: Obtaining node description information corresponding to the development subtask matching the current process node; Determine at least one task step of the current development subtask and the execution logic between the task steps according to the node description information; The prompt word matching the current process node is generated according to the task step and the execution logic of the task step.

3. The method according to claim 2, characterized in that The obtaining of the intermediate development result matching the previous process node includes: When at least one of the task steps corresponding to the previous process node is executed, obtaining a response result of at least one of the task steps, wherein the response result includes at least one of the following: requirement description information, text information, upload information, code information, deployment information, and notification information; The response result of at least one of the task steps is used as the intermediate development result matching the previous process node.

4. The method according to claim 2, characterized in that: The target query statement is obtained by combining the prompt word matching the current process node with the intermediate development result, including: Acquire the intermediate development result matching the previous process node, wherein the intermediate development result includes at least one of the following: requirement description information, text information, upload information, code information, deployment information, and notification information; The prompt word matching the current process node and the intermediate development result matching the previous process node are concatenated to obtain the target query statement matching the current process node.

5. The method according to claim 2, characterized in that: The step of inputting the target query statement into a target language model to obtain an intermediate execution result matching the current process node includes: Determine at least one function method for executing at least one of the task steps matching the current process node according to the current process node matching the target query statement; Determining function call parameters corresponding to at least one of the function methods from the intermediate development results matching the previous process node; Calling at least one of the function methods respectively according to the function call parameters corresponding to at least one of the function methods; The calling result of at least one of the function methods is used as the intermediate execution result matching the current process node.

6. The method according to claim 5, characterized in that Before obtaining N process nodes matching the target development task, the method further includes: Obtain the node description information corresponding to the development subtask; According to the node description information, the function method corresponding to at least one of the task steps is edited and configured.

7. The method according to claim 1, characterized in that After obtaining N process nodes matching the target development task, the method further includes: In the case where the development subtask is an interface document writing task, the task steps of the development subtask include: reading requirement description information, generating an interface document, and transmitting the interface document to an interface document management system; In the case where the development subtask is a task of creating a code branch, the task steps of the development subtask include: reading the requirement description information, generating a branch name, and creating a code branch matching the requirement description information from a code library; In the case where the development subtask is a code review task, the task steps of the development subtask include: reading the requirement description information, reviewing according to the requirement description information and the submitted change code, and merging the code into a test branch; In the case where the development subtask is a test code deployment task, the task steps of the development subtask include: reading project code information and deploying the code of the test branch to a test environment server; In the case where the development subtask is a task of merging a trunk branch, the task steps of the development subtask include: reading the requirement description information, reading the project code information, and merging the code of the test branch into the main branch; In the case where the development subtask is a task of submitting a marked version code, the task steps of the development subtask include: reading the requirement description information, reading the project code information, generating version information according to the requirement description information and the submitted changed code, and marking from the main branch; In the case where the development subtask is a task of deploying formal code, the task steps of the development subtask include: reading version information, reading the requirement description information, and deploying the marked version code to an online environment server.

8. The method according to claim 1, characterized in that Before obtaining the intermediate development result matching the previous process node, the process further includes: In the first task processing system corresponding to the current process node, receiving event notification information sent by the second event detection task pre-registered in the second task processing system matching the previous process node through the pre-registered first event detection task; Determine, according to the event notification information, to trigger the development subtask corresponding to the current process node.

9. A device for automating a development process, characterized in that: include: A first acquisition unit is configured to acquire N process nodes matching a target development task, wherein N is an integer greater than or equal to 2, and the N process nodes respectively correspond to a plurality of development subtasks of the target development task; Repeat the following steps until the target code matching the target development task is deployed to the target development platform: The second acquisition unit acquires the intermediate development result matching the previous process node; A splicing unit, splicing the prompt word matching the current process node with the intermediate development result to obtain a target query statement, wherein the target query statement is used to execute the development subtask matching the current process node based on the task execution interface matching the prompt word; An execution unit inputs the target query statement into a target language model to obtain an intermediate execution result matching the current process node, wherein the intermediate execution result matching the current process node is obtained by the target language model based on the task execution interface and the intermediate development result matching the previous process node, and the intermediate execution result is used to generate the target code matching the target development task; The updating unit uses the current process node as the previous process node and updates the next process node as the current process node.

10. A computer-readable storage medium, characterized in that: The computer-readable storage medium includes a stored program, wherein the program is executed by a processor to perform the method described in any one of claims 1 to 8.

11. A computer program product comprising a computer program / instructions, characterized in that When the computer program / instructions are executed by a processor, the steps of the method according to any one of claims 1 to 8 are implemented.

12. An electronic device comprising a memory and a processor, characterized in that: A computer program is stored in the memory, and the processor is configured to execute the method according to any one of claims 1 to 8 through the computer program.

Images