Software development method, device, equipment, system, storage medium and program product

Abstract

The application provides a software development method, device, equipment, system, storage medium and program product. In the method, after the main agent obtains a software requirement file, when a preset trigger condition of each software development stage in the software development process is established, the corresponding target file is determined according to the software requirement file and the received stage file, and then the file storage path of the target file is sent to the sub-agent corresponding to the software development stage. The sub-agent obtains the target file according to the file storage path, and then generates the stage file or generates the stage file and the target software, and sends the stage file to the main agent. The scheme generates the target software through the cooperation of the main agent and the sub-agent, reduces the burden of a single processing main body in maintaining a large number of full-process contexts, and thus improves the efficiency of software development and the matching degree of software and user requirements.

Description

Technical Field

[0001] This application relates to the field of software engineering technology, and in particular to a software development method, apparatus, equipment, system, storage medium, and program product. Background Technology

[0002] With the continuous development of technology, the application fields of intelligent agents are becoming increasingly widespread. In the field of software development, intelligent agents can also be used to implement software development.

[0003] In existing technologies, the typical approach to software development using intelligent agents involves the user inputting software requirements documents into an intelligent agent, which then develops the software based on these requirements documents and generates the software.

[0004] However, developing software with only one agent can lead to a large amount of context for the agent, resulting in lower software generation efficiency and a lower degree of matching between the software and user needs. Summary of the Invention

[0005] The software development methods, apparatus, devices, systems, storage media, and program products provided in this application are intended to solve the problems of low software generation efficiency and low matching degree between software and user needs caused by using only one intelligent agent for software development in the prior art.

[0006] In a first aspect, embodiments of this application provide a software development method applied to an active intelligent agent, the method comprising:

[0007] Obtain the software requirements document;

[0008] For each software development stage in the software development process, when the preset trigger condition of the software development stage is met, the target file corresponding to the software development stage is determined according to the software requirements file or the received stage file; the file storage path of the target file is sent to the sub-agent corresponding to the software development stage; the software development stage is a requirements summary extraction stage, code acquisition stage, technical solution generation stage, or software generation stage; the sub-agent is used to generate the stage file corresponding to the software development stage according to the target file;

[0009] For each software development stage, receive the stage file corresponding to the software development stage sent by the sub-agent corresponding to that software development stage.

[0010] In one possible implementation, when the software requirements document is obtained, the method further includes: storing the software requirements document and determining the stage status of each software development stage as not started;

[0011] For each software development stage, when the preset triggering condition of the software development stage is met, the method further includes: updating the stage status of the software development stage to in progress;

[0012] For each software development stage, upon receiving the stage file corresponding to the software development stage sent by the sub-agent corresponding to the software development stage, the method further includes: updating the stage status of the software development stage to "completed".

[0013] In one possible implementation, the preset trigger condition for the requirements summary extraction stage is: the software requirements file has been stored.

[0014] The preset triggering condition for the code acquisition stage is that the stage status of the requirement summary extraction stage is completed.

[0015] The preset triggering condition for the technical solution generation stage is that the stage status of the code acquisition stage is completed;

[0016] The preset trigger condition for the software generation stage is that the stage status of the technical solution generation stage is completed.

[0017] In one possible implementation, for each software development stage, upon receiving a stage file corresponding to the software development stage sent by the sub-agent corresponding to the software development stage, the method further includes: storing the stage file;

[0018] The target file corresponding to the requirements summary extraction stage is: the software requirements file;

[0019] The target file corresponding to the code acquisition phase is the phase file corresponding to the requirement summary extraction phase.

[0020] The target files corresponding to the technical solution generation stage are: the stage file corresponding to the requirement summary extraction stage, and the stage file corresponding to the code acquisition stage;

[0021] The target files corresponding to the software generation stage are: the stage file corresponding to the requirement summary extraction stage, the stage file corresponding to the code acquisition stage, and the stage file corresponding to the technical solution generation stage.

[0022] In one possible implementation, updating the phase status of the software development phase to "completed" includes:

[0023] If, within a preset time period after sending the file storage path to the sub-agent corresponding to the software development stage, the stage status of the software development stage is received from the sub-agent, the stage status of the software development stage is updated to "completed".

[0024] In one possible implementation, the method further includes:

[0025] If, within a preset time period after sending the file storage path to the sub-agent corresponding to the software development stage, the stage file corresponding to the software development stage is not received from the sub-agent, then the target file is obtained according to the file storage path, and the current running result of the sub-agent is obtained.

[0026] Based on the current running results and the target file, generate the stage file corresponding to the software development stage, or generate the stage file and target software corresponding to the software development stage.

[0027] Update the phase status of the software development phase to "completed".

[0028] In one possible implementation, the stage file of the code acquisition stage includes at least one code identifier, as well as code and code type corresponding to each code identifier, wherein the code type is front-end code or back-end code;

[0029] The phase files for the software generation phase include modified code identifiers;

[0030] The method for updating the phase status of the software development phase to "completed" further includes:

[0031] If all the code types corresponding to the modified code identifiers include backend code, a coverage check request is sent to the test sub-agent so that the test sub-agent can obtain the target coverage, generate a coverage test result indicating whether the coverage test has passed based on the target coverage and a preset coverage threshold, and send the coverage test result to the main agent.

[0032] Upon receiving the coverage test result sent by the test sub-agent, determine whether the coverage test result indicates that the coverage test has passed;

[0033] If the coverage test result indicates that the coverage test has passed, a software development report is generated based on the software requirements document, the coverage test result, and the phase document for each sub-agent.

[0034] In one possible implementation, the method further includes:

[0035] If the coverage test result indicates that the coverage test has failed, a software repair request is sent to the repair sub-agent so that the repair sub-agent can obtain the repair test case file, test the target software according to the repair test case file, obtain the target coverage and store it, and then send the repair test case file to the main agent.

[0036] Upon receiving the software test results and the repair test case file, a coverage check request is sent to the test sub-agent to enable the test sub-agent to obtain the target coverage, generate coverage test results based on the target coverage and a preset coverage threshold, and send the coverage test results to the main agent.

[0037] Upon receiving the coverage test result sent by the test sub-agent, determine whether the coverage test result indicates that the coverage test has passed;

[0038] If the coverage test result indicates that the coverage test failed, repeat the above steps until the coverage test result indicates that the coverage test passed. Then, generate a software development report based on the software requirements document, the coverage test result, the repair test case file, and the phase file for each sub-agent.

[0039] In one possible implementation, the method further includes:

[0040] If the code type corresponding to all modified code identifiers does not include backend code, generate a coverage test skip file and store it.

[0041] A software development report is generated based on the coverage test skip file, the software requirements file, and the phase file for each sub-agent.

[0042] In one possible implementation, when the coverage test result sent by the test sub-agent is received, determining whether the coverage test result indicates that the coverage test has passed includes:

[0043] If, within a preset time period after sending a coverage check request to the test sub-agent, the coverage test result is received from the test sub-agent, then it is determined whether the coverage test result indicates that the coverage test has passed.

[0044] In one possible implementation, the method further includes:

[0045] If the coverage test result is not received from the test sub-agent within a preset time after sending the coverage check request, the target coverage is obtained, and a coverage test result indicating whether the coverage test has passed is generated based on the target coverage and a preset coverage threshold.

[0046] In one possible implementation, upon receiving the repair test case file, sending a coverage check request to the test sub-agent includes:

[0047] If, within a preset time period after sending a software repair request to the repair sub-agent, the repair test case file is received from the repair sub-agent, then a coverage check request is sent to the test sub-agent.

[0048] In one possible implementation, the method further includes:

[0049] If the repair test case file is not received from the repair sub-agent within a preset time after sending the software repair request to the repair sub-agent, then the repair test case file is obtained based on the current running result of the repair sub-agent, and the target software is tested based on the repair test case file to obtain the target coverage.

[0050] The repair test case file and the target coverage are stored, and a coverage check request is sent to the test sub-agent.

[0051] Secondly, embodiments of this application provide a software development method applied to sub-agents corresponding to each software development stage in the software development process, wherein the software development stage is a requirements summary extraction stage, a code acquisition stage, a technical solution generation stage, or a software generation stage, and the method includes:

[0052] Receive the file storage path sent by the main intelligent agent;

[0053] Obtain the target file based on the file storage path;

[0054] Run the program according to the target file to generate the phase file corresponding to the software development phase, or generate the phase file and target software corresponding to the software development phase.

[0055] The phase file corresponding to the software development phase is sent to the main intelligent agent.

[0056] Thirdly, embodiments of this application provide a software development apparatus, comprising:

[0057] The acquisition module is used to acquire software requirements documents;

[0058] The sending module is used to, for each software development stage in the software development process, when a preset trigger condition for the software development stage is met, determine the target file corresponding to the software development stage based on the software requirements file or the received stage file; and send the file storage path of the target file to the sub-agent corresponding to the software development stage; wherein the software development stage is a requirements summary extraction stage, code acquisition stage, technical solution generation stage, or software generation stage; and the sub-agent is used to generate the stage file corresponding to the software development stage based on the target file.

[0059] The receiving module is used to receive, for each software development stage, a stage file corresponding to that software development stage sent by the sub-agent corresponding to that software development stage.

[0060] Fourthly, embodiments of this application provide a software development apparatus, comprising:

[0061] The receiving module is used to receive the file storage path sent by the main intelligent agent;

[0062] Processing module, used for:

[0063] Obtain the target file based on the file storage path;

[0064] Run the program based on the target file to generate a stage file, or generate a stage file and the target software; the stage file and the target software correspond to the software development stage in the software development process, and the software development stage is the requirement summary extraction stage, the code acquisition stage, the technical solution generation stage, or the software generation stage;

[0065] The sending module is used to send the stage file to the main intelligent agent.

[0066] Fifthly, embodiments of this application provide an electronic device, including:

[0067] Processor, memory, communication interface;

[0068] The memory is used to store the executable instructions of the processor;

[0069] The processor is configured to execute the software development method described in any of the first aspects by executing the executable instructions.

[0070] Sixthly, embodiments of this application provide an electronic device, including:

[0071] Processor, memory, communication interface;

[0072] The memory is used to store the executable instructions of the processor;

[0073] The processor is configured to execute the software development method described in the second aspect by executing the executable instructions.

[0074] Seventhly, embodiments of this application provide a software development system, including:

[0075] The main intelligent agent and the sub-intelligent agents corresponding to each stage of software development in the software development process;

[0076] The main intelligent agent is used to execute the software development method described in any of the first aspects;

[0077] The sub-agent is used to execute the software development method described in the second aspect.

[0078] Eighthly, embodiments of this application provide a readable storage medium having a computer program stored thereon, wherein the computer program, when executed by a processor, implements any one of the first aspects or the software development method described in the second aspect.

[0079] Ninthly, embodiments of this application provide a computer program product, including a computer program, which, when executed by a processor, is used to implement any of the first aspects or the software development method described in the second aspect.

[0080] The software development method, apparatus, device, system, storage medium, and program product provided in this application, after obtaining the software requirements document through the main intelligent agent, determines the corresponding target file based on the software requirements document and the received stage file when the preset trigger conditions of each software development stage are met. Then, the file storage path of the target file is sent to the sub-intelligent agent corresponding to that software development stage. The sub-intelligent agent obtains the target file based on the file storage path and then runs to generate the stage file, or generates both the stage file and the target software, and sends the stage file to the main intelligent agent. This solution reduces the burden of a single processing entity continuously maintaining a large amount of full-process context by collaboratively generating the target software through the main intelligent agent and sub-intelligent agents, and achieves orderly connection and status recording of stage inputs and outputs, thereby improving the efficiency of software development, the matching degree between software and user needs, controllability, and traceability. Attached Figure Description

[0081] The accompanying drawings, which are incorporated in and form part of this specification, illustrate embodiments consistent with this application and, together with the description, serve to explain the principles of this application.

[0082] Figure 1 A flowchart illustrating an embodiment of the software development method provided in this application;

[0083] Figure 2 A flowchart illustrating Embodiment 2 of the software development method provided in this application;

[0084] Figure 3 This is a schematic diagram of the structure of the software development apparatus provided in Embodiment 1 of this application;

[0085] Figure 4 This is a schematic diagram of the structure of Embodiment 2 of the software development apparatus provided in this application;

[0086] Figure 5 A schematic diagram of the structure of an electronic device provided in this application Figure 1 ;

[0087] Figure 6 A schematic diagram of the structure of an electronic device provided in this application Figure 2 ;

[0088] Figure 7 This is a schematic diagram of the structure of a software development system provided in this application.

[0089] The accompanying drawings illustrate specific embodiments of this application, which will be described in more detail below. These drawings and descriptions are not intended to limit the scope of the concept in any way, but rather to illustrate the concept of this application to those skilled in the art through reference to particular embodiments. Detailed Implementation

[0090] Exemplary embodiments will now be described in detail, examples of which are illustrated in the accompanying drawings. When the following description relates to the drawings, unless otherwise indicated, the same numbers in different drawings denote the same or similar elements. The embodiments described in the following exemplary embodiments do not represent all embodiments consistent with this application. Rather, they are merely examples of apparatuses and methods consistent with some aspects of this application as detailed in the appended claims.

[0091] The terms “first,” “second,” “third,” “fourth,” etc. (if present) in the specification, claims, and accompanying drawings of this application are used to distinguish similar objects and are not necessarily used to describe a particular order or sequence. It should be understood that such data can be interchanged where appropriate so that the embodiments of this application described herein can be implemented in orders other than those illustrated or described herein. Furthermore, the terms “comprising” and “having,” and any variations thereof, are intended to cover a non-exclusive inclusion; for example, a process, method, system, product, or apparatus that comprises a series of steps or units is not necessarily limited to those steps or units explicitly listed, but may include other steps or units not explicitly listed or inherent to such processes, methods, products, or apparatus.

[0092] With the continuous development of technology, the application fields of intelligent agents are becoming increasingly widespread. In the field of software development, intelligent agents can also be used to implement software development.

[0093] In existing technologies, the typical approach to software development using intelligent agents involves the user inputting software requirements documents into an intelligent agent, which then develops the software based on these requirements documents.

[0094] This intelligent agent sequentially completes multiple software development stages, continuously incorporating previous outputs as subsequent inputs during processing. While this approach covers the basic chain from requirements to software output, its operation relies on the same processing agent maintaining a large amount of context information over a long period. As the context from multiple software development stages accumulates, problems such as slow response, distorted understanding of requirements, and unstable generated results can easily arise, leading to low software generation efficiency and a low degree of matching between the software and user needs.

[0095] To address the problems existing in the prior art, the inventors, during their research on software development methods, discovered that software development can be carried out collaboratively by a main intelligent agent and multiple sub-intelligent agents. The main intelligent agent controls the execution order of software development stages, while the sub-intelligent agents implement solutions for different software development stages. This reduces the context of each intelligent agent, improves software generation efficiency, and enhances the matching degree between the software and user needs. After obtaining the software requirements document, the main intelligent agent, when the preset trigger conditions for each software development stage are met, determines the target file corresponding to the software development stage based on the software requirements document or the received stage file; it then sends the file storage path of the target file to the corresponding sub-intelligent agent. The sub-intelligent agent retrieves the target file according to the file storage path, runs the target file, generates the stage file corresponding to the software development stage, or generates the stage file and target software corresponding to the software development stage; and then sends the stage file corresponding to the software development stage back to the main intelligent agent. Based on the above inventive concept, the software development scheme in this application was designed.

[0096] In this application, the main intelligent agent and the sub-intelligent agents can be deployed on the same electronic device or on different electronic devices. The electronic devices can be computers, servers, terminal devices, etc. This application does not limit the electronic devices used to deploy the intelligent agents; the specific devices can be determined based on actual circumstances.

[0097] The following provides examples illustrating the application scenarios of the software development method provided in this application.

[0098] For example, in this application scenario, a user wants to develop software. After creating a software requirements document, the user inputs it into an electronic device. The electronic device is equipped with a main intelligent agent and sub-intelligent agents. The main intelligent agent can then obtain the software requirements document.

[0099] For each software development stage in the software development process, when the preset triggering conditions of that software development stage are met, the main intelligent agent determines the target file corresponding to that software development stage based on the software requirements document or the received stage file; and sends the file storage path of the target file to the sub-intelligent agent corresponding to that software development stage.

[0100] The software development phase includes the requirements summary extraction phase, code acquisition phase, technical solution generation phase, or software generation phase.

[0101] The sub-agent retrieves the target file based on the file storage path; runs according to the target file to generate the phase file corresponding to the software development phase, or generates the phase file and target software corresponding to the software development phase; and sends the phase file corresponding to the software development phase to the main agent.

[0102] For each software development phase, the main agent receives the phase file corresponding to that software development phase from the sub-agent.

[0103] During the software generation phase, the sub-agent generates the target software, which is the software that the user wants to develop.

[0104] It should be noted that this solution is applicable not only to the development of entirely new software, but also to the addition, deletion, or modification of functions on existing software.

[0105] It should be noted that the above scenario is only an example of an application scenario provided by the embodiments of this application. The embodiments of this application do not limit the actual form of the various devices included in the scenario. In the specific application of the solution, it can be set according to actual needs.

[0106] The technical solution of this application will now be described in detail through specific embodiments. It should be noted that the following specific embodiments can be combined with each other, and the same or similar concepts or processes may not be described again in some embodiments.

[0107] Figure 1 This is a flowchart illustrating an embodiment of the software development method provided in this application. This embodiment describes how the main intelligent agent controls the execution order of each software development stage, and how sub-intelligent agents implement each software development stage, thereby achieving software development. The method in this embodiment can be implemented through software, hardware, or a combination of both. Figure 1 As shown, this software development method specifically includes the following steps:

[0108] S101: The main intelligent agent obtains the software requirements document.

[0109] In this step, in order to carry out software development, the main agent needs to obtain the software requirements document.

[0110] The software requirements document serves as the initial input for the entire software development process, recording the functional requirements, business constraints, interface requirements, delivery scope, acceptance criteria, and other related information for the software to be developed. The software requirements document can be a structured document, a semi-structured document, or an unstructured text document. Specifically, it can be a requirements specification, product document, interface protocol document, prototype description document, images, audio, or a combination thereof. This application does not limit the content and format of the software requirements document; these can be determined based on actual circumstances.

[0111] Software requirement documents can be obtained by the main agent receiving uploaded files through a task submission interface, by retrieving requirement documents from a project management system and then reading the corresponding files, by an external requirement management service providing the main agent with a software requirement document identifier, and by the main agent locating and loading the file based on this identifier, or by user input. This application does not limit the method of obtaining software requirement documents; it can be determined according to the actual situation.

[0112] S102: For each software development stage in the software development process, when the preset triggering conditions of the software development stage are met, the main intelligent agent determines the target file corresponding to the software development stage based on the software requirements file or the received stage file; and sends the file storage path of the target file to the sub-intelligent agent corresponding to the software development stage.

[0113] In this step, after the main agent obtains the software requirements document, in order to control the software development process, it needs to determine whether the preset trigger conditions for each software development stage are met.

[0114] Different software development stages correspond to different processing objectives and different sub-agents. Preset trigger conditions are used to determine whether a certain stage enters the execution state.

[0115] When the preset triggering conditions of the software development phase are met, the target file corresponding to the software development phase is determined according to the software requirements document or the received phase document; then the file storage path of the target file is sent to the sub-agent corresponding to the software development phase.

[0116] By passing the file storage path to the sub-agent instead of directly passing the target file, the main agent does not need to include the target file in its own context. This further reduces the main agent's context, improves software development efficiency, and enhances the match between the software and user needs.

[0117] The software development phase includes a requirements summary extraction phase, a code acquisition phase, a technical solution generation phase, or a software generation phase. The sub-agent is used to generate the phase file corresponding to the software development phase based on the target file. The phase file is the processing result file generated and returned by the sub-agent and is used as part of the input for subsequent phases.

[0118] It should be noted that when the main intelligent agent obtains the software requirements file, it stores the software requirements file and determines the stage status of each software development phase as "not started".

[0119] For each software development stage, when the preset triggering conditions for that stage are met, the main agent indicates that the software development stage can proceed and updates its stage status to "in progress".

[0120] For each software development phase, when the main agent receives the phase file corresponding to that software development phase from the sub-agent, it indicates that the software development phase has been completed, and updates the phase status of the software development phase to "completed".

[0121] The main intelligent agent can store software requirements documents and the stage states of each software development phase into a file storage space, thereby determining the file storage path of the files in the file storage space. The file storage space can be a database, remote object storage, message queue, directory, etc. This embodiment does not limit the file storage space and can be determined according to actual conditions. Stage states are stored in state files, which are then stored in the file storage space. State files can be JSON files, YAML files, databases, etc. This embodiment does not limit the state files and can be determined according to actual conditions.

[0122] By adopting the above method, the software requirements documents and the stage status of each software development stage can be uniformly saved and continuously updated. The stage execution process has clear progress markers, and the main intelligent agent can accurately identify the stage of each software development stage based on the status records, thereby improving the consistency of stage scheduling and result reception, and enhancing the controllability and traceability of the entire software development chain.

[0123] It should be noted that the preset trigger condition for the requirements summary extraction stage is that the software requirements file has been stored.

[0124] The preset trigger condition for the code acquisition phase is: the phase status of the requirement summary extraction phase is completed.

[0125] The preset trigger condition for the technical solution generation stage is: the stage status of the code acquisition stage is completed.

[0126] The preset trigger condition for the software generation phase is: the phase status of the technical solution generation phase is completed.

[0127] Based on the triggering conditions of each software development stage, the software development process proceeds in the order of requirement summary extraction stage, code acquisition stage, technical solution generation stage, and software generation stage, and each stage will not be executed repeatedly.

[0128] The requirement summary extraction stage can only be carried out after the software requirement file is stored. This allows the file storage path of the software requirement file to be obtained, and the sub-agents can carry out the requirement summary extraction stage.

[0129] The triggering conditions for the code acquisition stage, the technical solution generation stage, and the software generation stage depend on whether the stage status of the previous software development stage is completed. The main agent determines the file storage path of the target file and distributes it to the next sub-agent only after detecting that the previous software development stage is completed.

[0130] This approach enables process control during software development, preventing duplicate executions or omissions during the development phase.

[0131] In addition, by maintaining the stage status of each software development stage, it is possible to determine which software development stages have been completed in the event of an interruption in the software development process. Thus, the unfinished software development stages can continue to be executed without having to restart the software development process, thereby improving efficiency.

[0132] In one implementation, the preset triggering condition for the software generation phase is: the phase status of the technical solution generation phase is completed, and a confirmation command sent by the user is received. After receiving the phase file of the technical solution generation phase, the main agent outputs it for user confirmation. If the user confirms that there are no errors, the user can send a confirmation command to the main agent. This approach can improve the matching degree between the software and user needs.

[0133] It should be noted that for each software development stage, when the main agent receives the stage file corresponding to the software development stage from the sub-agent, it stores the stage file, which can be stored in the file storage space.

[0134] The target file corresponding to the requirements summary extraction phase is the software requirements document.

[0135] The target file for the code acquisition phase is the same as the phase file for the requirements summary extraction phase.

[0136] The target files corresponding to the technical solution generation phase are: the phase file corresponding to the requirement summary extraction phase, and the phase file corresponding to the code acquisition phase.

[0137] The target files corresponding to the software generation phase are: the phase file corresponding to the requirements summary extraction phase, the phase file corresponding to the code acquisition phase, and the phase file corresponding to the technical solution generation phase.

[0138] In one implementation, after the main agent sends the file storage path to the sub-agent corresponding to the software development stage, it can monitor whether it receives the stage file corresponding to the software development stage from the sub-agent within a preset time period.

[0139] If, within a preset time period after sending the file storage path to the sub-agent corresponding to the software development stage, the system receives the stage file corresponding to that stage from the sub-agent, it indicates that the sub-agent has completed the software development stage in a timely manner, and the stage status of the software development stage is updated to "completed".

[0140] If, within a preset time period after sending the file storage path to the sub-agent corresponding to this software development phase, the master agent does not receive the corresponding phase file from the sub-agent, it indicates that the sub-agent has failed to complete the software development phase in a timely manner, its efficiency is low, or it has malfunctioned. To ensure the efficiency of software development and prevent the process from stopping, the master agent takes over the work of the sub-agent. This means retrieving the target file based on the file storage path and obtaining the current running results of the sub-agent; then, based on the current running results and the target file, generating the corresponding phase file for this software development phase, or generating the corresponding phase file and the target software; and updating the phase status of this software development phase to "completed".

[0141] It should be noted that the preset duration can be 20 minutes, 30 minutes, 1 hour, etc. This application embodiment does not limit the preset duration and can be determined according to the actual situation.

[0142] S103: After receiving the file storage path sent by the master agent, the sub-agent obtains the target file according to the file storage path.

[0143] In this step, after the main agent sends the file storage path to the sub-agent, the sub-agent receives the file storage path and then needs to obtain the target file based on the file storage path in order to carry out the software development phase.

[0144] S104: The sub-agent runs according to the target file, generating the phase file corresponding to the software development phase, or generating the phase file and target software corresponding to the software development phase.

[0145] In this step, after the sub-agent obtains the target file, it runs according to the target file to generate the phase file corresponding to the software development stage, or to generate the phase file and target software corresponding to the software development stage.

[0146] Specifically, in the requirement summary extraction stage, the sub-agent corresponding to this stage performs a summary extraction operation on the software requirement document, and generates the stage file for this stage after obtaining the requirement summary, which is the requirement summary file.

[0147] It should be noted that the sub-agents corresponding to the requirement summary extraction stage include a trained large language model, which is capable of extracting requirement summaries from software requirement documents.

[0148] It should be noted that the requirements summary file includes code identifiers, execution cycles, requirements documents, etc. This application embodiment does not limit the content of the requirements summary file, and it can be determined according to the actual situation.

[0149] For the code acquisition phase, the corresponding sub-agent in this phase retrieves the corresponding code and code type from the code repository based on the code identifiers in the requirements summary file. Then, based on each code identifier and the corresponding code and code type, it generates the phase file for this phase, which is essentially generating the code file.

[0150] It should be noted that the code type is either front-end code or back-end code; the code repository stores multiple code snippets, as well as the code identifier and code type for each code snippet.

[0151] It should be noted that the code can be source file code, interface code, configuration code, permission code, test log code, etc. This application embodiment does not limit the code and can be determined according to the actual situation.

[0152] It should be noted that this sub-agent can also generate front-end and back-end code identifiers indicating the presence of back-end code, along with the reason and suggested actions, based on the code type, and write these to the code file. If back-end code exists in all code types, a front-end and back-end code identifier indicating the presence of back-end code is generated, the reason being the existence of back-end code, and the suggested action being to perform coverage testing. If back-end code does not exist in any code type, a front-end and back-end code identifier indicating the absence of back-end code is generated, the reason being the absence of back-end code, and the suggested action being to skip coverage testing.

[0153] It should be noted that when the preset triggering conditions of the code acquisition phase are met, the main agent can also send the storage path of the file storage space to the corresponding sub-agent of that phase.

[0154] In the technical solution generation stage, the corresponding sub-agent generates the technical solution based on the requirements summary file and the code file, and then writes the technical solution into a blank file to obtain the stage file for this stage, which is the generated technical solution file.

[0155] It should be noted that the technical solution is a scheme for how to process code, including artificial intelligence (AI) execution scheme, prerequisites, function point implementation, task decomposition, regression checklist, test-driven development (TDD) and coverage requirements, execution stop conditions, etc. The embodiments of this application do not limit the content of the technical solution, which can be determined according to the actual situation.

[0156] It should be noted that the sub-agents corresponding to the technical solution generation stage include a trained large language model, which can generate technical solutions based on the requirements summary file and code file.

[0157] During the software generation phase, the corresponding sub-agent generates the target software and a modification specification file based on the requirements summary file, code file, and technical solution file. The modification specification file serves as the phase file for this phase. It includes identifiers for modified code, indicating which code has been modified.

[0158] It should be noted that the sub-agents corresponding to the software generation stage include a trained large language model, which can generate requirement summary files, code files, and technical solution files, as well as target software and modification description files.

[0159] It should be noted that the sub-agents corresponding to the software generation phase can also test the target software based on the trial code in the code file, generate test results and add them to the modification description file, and also obtain the target coverage.

[0160] S105: The sub-agent sends the phase file corresponding to the software development phase to the master agent.

[0161] In this step, after the sub-agent generates the phase file corresponding to the software development phase, it needs to send the phase file to the master agent in order to proceed with subsequent phases.

[0162] In one implementation, the sub-agent can store the stage file in the file storage space and send the file storage path of the stage file to the main agent.

[0163] S106: For each software development stage, the main agent receives the stage file corresponding to that software development stage from the sub-agent.

[0164] In this step, the sub-agent sends the phase file to the master agent, which then receives the phase file to determine the target files for other software development phases.

[0165] The main agent can store stage files in the file storage space in order to obtain the file storage path.

[0166] The software development method provided in this embodiment, after obtaining the software requirements document through the main intelligent agent, determines the corresponding target file based on the software requirements document and the received stage file when the preset trigger conditions of each software development stage are met. Then, it sends the file storage path of the target file to the sub-intelligent agent corresponding to that software development stage. The sub-intelligent agent obtains the target file based on the file storage path and then runs to generate the stage file, or generates both the stage file and the target software, and sends the stage file to the main intelligent agent. This solution reduces the burden of a single processing entity continuously maintaining a large amount of full-process context by collaboratively generating the target software through the main intelligent agent and sub-intelligent agents. It also achieves orderly connection and status recording of stage inputs and outputs, thereby improving the efficiency of software development, the matching degree between the software and user needs, controllability, and traceability.

[0167] In addition, by passing the file storage path of the target file to the child agent, the main agent does not need to put the target file in its own context, which reduces the context of the main agent and further improves the software generation efficiency and the matching degree between the software and user needs.

[0168] Compared to existing technologies that rely on human intervention for software development, this solution eliminates the need for human involvement, thereby improving software development efficiency.

[0169] By storing phase documents and software requirements documents, the software development process can be traced by viewing these documents.

[0170] Figure 2 This is a flowchart illustrating a second embodiment of the software development method provided in this application. Based on the above embodiments, this application's embodiment describes the process after the target software is generated, the main intelligent agent updates the stage status of the software development phase to "completed," determines whether coverage testing is needed, and, when it is determined that coverage testing is needed, performs coverage testing. Figure 2 As shown, this software development method specifically includes the following steps:

[0171] S201: Determine whether the code types corresponding to all modified code identifiers include backend code; if the code types corresponding to all modified code identifiers include backend code, then execute steps S202-S208; if the code types corresponding to all modified code identifiers do not include backend code, then execute steps S209-S210.

[0172] In this step, since the sub-agent tested the target software during the software generation phase and generated target coverage data which is stored in the file storage space, a low target coverage indicates incomplete testing of the software. Therefore, it is necessary to obtain repair test cases and retest the target software. Furthermore, target coverage is only needed to determine whether retesting is required when the backend code is modified. This is because the frontend code does not involve logical code, only interface-related code, and the unmodified backend code does not need to be tested. Therefore, to determine whether to retest the target software, it is necessary to determine whether coverage testing is required. This requires the main agent to determine whether the code type corresponding to all modified code identifiers includes backend code.

[0173] The code acquisition phase file includes at least one code identifier, as well as the corresponding code and code type for each code identifier. The code type is either front-end code or back-end code. The software generation phase file includes modified code identifiers.

[0174] S202: Send a coverage check request to the test sub-agent so that the test sub-agent can obtain the target coverage, generate a coverage test result indicating whether the coverage test has passed based on the target coverage and the preset coverage threshold, and send the coverage test result to the main agent.

[0175] In this step, if all modified code identifiers include backend code in their corresponding code types, it indicates that coverage testing is required. A coverage check request is then sent to the test sub-agent to obtain the target coverage. Based on the target coverage and a preset coverage threshold, the test sub-agent generates a coverage test result indicating whether the coverage test passed or failed, and sends the coverage test result to the main agent. The main agent can then store the coverage test result in a file storage space.

[0176] The test sub-agent can obtain the target coverage from the file storage space. If the target coverage is greater than the preset coverage threshold, a coverage test result indicating that the coverage test has passed is generated; if the target coverage is less than or equal to the preset coverage threshold, a coverage test result indicating that the coverage test has failed is generated.

[0177] It should be noted that the preset coverage threshold can be 75%, 80%, 90%, etc. This application embodiment does not limit the preset coverage threshold, and it can be determined according to the actual situation.

[0178] S203: Upon receiving the coverage test result sent by the test sub-agent, determine whether the coverage test result indicates that the coverage test has passed; if the coverage test result indicates that the coverage test has passed, proceed to step S204; if the coverage test result indicates that the coverage test has failed, proceed to steps S205-S208.

[0179] In this step, after the test sub-agent sends the coverage test result to the master agent, the master agent can receive the coverage test result. Then, in order to determine whether the target software needs to be retested, it is necessary to determine whether the coverage test result indicates that the coverage test has passed.

[0180] In one implementation, after the main agent sends a coverage check request to the test sub-agent, it can monitor whether it receives the coverage test result sent by the test sub-agent within a preset time period.

[0181] If a coverage test result is received from the test sub-agent within a preset time after sending a coverage check request, it indicates that the test sub-agent has completed its work in a timely manner. In this case, it is determined whether the coverage test result indicates that the coverage test has passed.

[0182] If no coverage test result is received from the test sub-agent within a preset time after sending a coverage check request, it indicates that the test sub-agent has failed to complete its work in a timely manner, its efficiency is low, or it has malfunctioned. In order for the coverage test to proceed normally, the master agent takes over the work of the test sub-agent, which means obtaining the target coverage and generating a coverage test result indicating whether the coverage test has passed based on the target coverage and the preset coverage threshold.

[0183] S204: Generate a software development report based on the software requirements document, coverage test results, and phase documents for each sub-agent.

[0184] In this step, if the coverage test results indicate that the coverage test has passed, there is no need to retest the target software. Instead, a software development report is generated based on the software requirements document, the coverage test results, and the phase files for each sub-agent. In other words, the software development report is generated based on the data in the file storage space.

[0185] The process of generating a software development report can be as follows: save the data in the file storage space into a blank report to obtain the software development report.

[0186] It should be noted that the storage path of data in the file storage space can also be added to the software development report.

[0187] S205: Send a software repair request to the repair sub-agent so that the repair sub-agent can obtain the repair test case file, test the target software according to the repair test case file, obtain the software test results, and send the software test results and the repair test case file to the main agent.

[0188] In this step, if the coverage test result indicates that the coverage test failed, it means that the target software needs to be tested again. The main agent then sends a software repair request to the repair sub-agent so that the repair sub-agent can obtain the repair test case file, test the target software according to the repair test case file, store the target coverage, and send the repair test case file back to the main agent.

[0189] The repair sub-agent can obtain test case files from the test case library and store the generated target coverage in the file storage space.

[0190] It should be noted that the repair agent can also modify the target software to suit software testing.

[0191] It should be noted that the embodiments of this application do not limit the tools used to obtain the target coverage, and the tools can be determined according to the actual situation.

[0192] S206: Upon receiving the target coverage and repair test case files, a coverage check request is sent to the test sub-agent to enable it to obtain the target coverage. Based on the target coverage and the preset coverage threshold, the sub-agent generates coverage test results and sends the coverage test results to the main agent.

[0193] In this step, after the repair sub-agent sends the repair test case file to the master agent, the master agent receives the file and stores it in its storage space. Then, to re-perform coverage testing, a coverage check request is sent to the test sub-agent, enabling it to obtain the target coverage. Based on the target coverage and a preset coverage threshold, the test sub-agent generates coverage test results and sends these results to the master agent.

[0194] In one implementation, after the main agent sends a software repair request to the repair sub-agent, it can monitor whether it receives the repair test case file sent by the repair sub-agent within a preset time period.

[0195] If a repair test case file is received from the repair sub-agent within a preset time after sending a software repair request to the repair sub-agent, it indicates that the repair sub-agent has completed its work in a timely manner, and a coverage check request is sent to the test sub-agent.

[0196] If, within a preset timeframe after sending a software repair request to the repair sub-agent, no repair test case file is received from the repair sub-agent, it indicates that the repair sub-agent has failed to complete its work in a timely manner, its efficiency is low, or it has malfunctioned. To ensure that software testing proceeds normally, the master agent takes over the work of the repair sub-agent. This involves obtaining the current running results of the repair sub-agent, retrieving the repair test case file based on these results, testing the target software using the repair test case file to obtain the target coverage, storing the repair test case file and the target coverage, and sending a coverage check request to the test sub-agent.

[0197] The current running results of the repair sub-agent include test case files, which the main agent uses as the repair test case files; and it retrieves test cases that the repair sub-agent has not yet retrieved from the test case library and uses them as the repair test case files.

[0198] S207: Upon receiving the coverage test result sent by the test sub-agent, determine whether the coverage test result indicates that the coverage test has passed; if the coverage test result indicates that the coverage test has passed, proceed to step S208; if the coverage test result indicates that the coverage test has failed, return to proceed to step S205.

[0199] In this step, after the test sub-agent sends the coverage test result to the master agent, the master agent can receive the coverage test result. Then, in order to determine whether the target software needs to be retested, it is necessary to determine whether the coverage test result indicates that the coverage test has passed.

[0200] If the coverage test result indicates that the coverage test failed, then return to step S205, which means re-obtaining the repair test case file through the repair sub-agent to test the target software, re-obtaining the coverage test result through the test sub-agent, until the coverage test result indicates that the coverage test passed, and generating a software development report based on the data in the file storage space.

[0201] S208: Generate a software development report based on the software requirements document, coverage test results, target coverage, repair test case files, and phase files for each sub-agent.

[0202] In this step, if the coverage test results indicate that the coverage test has passed, there is no need to retest the target software. Instead, a software development report is generated based on the software requirements document, coverage test results, target coverage, repair test case files, and phase files for each sub-agent, which is based on the data in the file storage space.

[0203] It should be noted that the storage path of data in the file storage space can also be added to the software development report.

[0204] S209: Generate and store the coverage test skip file.

[0205] In this step, if the code type corresponding to all modified code identifiers does not include backend code, it means that coverage testing is not required. The main agent then generates a coverage test skip file and stores it in the file storage space.

[0206] The coverage test skip file includes a skip flag that indicates whether to skip the coverage test.

[0207] S210: Generate a software development report based on the coverage test skip file, software requirements file, and phase file for each sub-agent.

[0208] In this step, after the main agent stores the coverage test skip file, a software development report is generated based on the coverage test skip file, the software requirements file, and the phase file of each sub-agent. In other words, the software development report is generated based on the data in the file storage space.

[0209] It should be noted that the storage path of data in the file storage space can also be added to the software development report.

[0210] It should be noted that for each piece of data in the file storage space, the storage path of that data can be set in advance, and when the data is obtained, it will be stored in the corresponding storage path.

[0211] It should be noted that access permissions for files can be set for sub-agents, testing sub-agents, and repair sub-agents corresponding to each software development stage. For example, the sub-agents and testing sub-agents corresponding to the code acquisition stage can have read-only permissions; other sub-agents can have read and write permissions, which can ensure the security of the software development process.

[0212] The software development method provided in this embodiment avoids coverage test anomalies by not performing coverage testing when the code type corresponding to the modified code identifier does not include backend code. Furthermore, by using test and repair sub-agents, the target software can be retested even if testing is incomplete, thus improving the effectiveness of software testing.

[0213] The following are embodiments of the apparatus described in this application, which can be used to execute the embodiments of the method described in this application. For details not disclosed in the apparatus embodiments of this application, please refer to the embodiments of the method described in this application.

[0214] Figure 3 This is a schematic diagram of the structure of the software development apparatus provided in Embodiment 1 of this application; as shown below. Figure 3 As shown, the software development apparatus 30 includes:

[0215] Module 31 is used to obtain the software requirements document;

[0216] The sending module 32 is used to determine the target file corresponding to each software development stage when the preset trigger conditions of the software development stage are met, based on the software requirements file or the received stage file; and send the file storage path of the target file to the sub-agent corresponding to the software development stage; the software development stage is the requirements summary extraction stage, code acquisition stage, technical solution generation stage, or software generation stage; the sub-agent is used to generate the stage file corresponding to the software development stage based on the target file.

[0217] The receiving module 33 is used to receive the phase file corresponding to the software development phase sent by the sub-agent corresponding to the software development phase for each software development phase.

[0218] Furthermore, it also includes a processing module 34, for:

[0219] Upon obtaining the software requirements document, store the software requirements document and determine the stage status of each software development phase as "not started".

[0220] For each software development phase, when the preset trigger conditions for the software development phase are met, the phase status of the software development phase is updated to "in progress".

[0221] For each software development phase, upon receiving the phase file corresponding to the software development phase from the sub-agent, the phase status of the software development phase is updated to "completed".

[0222] Furthermore, the preset trigger condition for the requirements summary extraction stage is: the software requirements file has been stored;

[0223] The preset trigger condition for the code acquisition phase is: the phase status of the requirement summary extraction phase is completed;

[0224] The preset trigger condition for the technical solution generation stage is: the stage status of the code acquisition stage is completed;

[0225] The preset trigger condition for the software generation phase is: the phase status of the technical solution generation phase is completed.

[0226] Furthermore, processing module 34 is also used for:

[0227] For each software development phase, upon receiving the phase file corresponding to the software development phase from the sub-agent corresponding to that phase, the phase file is stored.

[0228] The target file corresponding to the requirements summary extraction phase is the software requirements document;

[0229] The target file for the code acquisition phase is the same as the phase file for the requirements summary extraction phase.

[0230] The target files corresponding to the technical solution generation stage are: the stage file corresponding to the requirement summary extraction stage, and the stage file corresponding to the code acquisition stage;

[0231] The target files corresponding to the software generation phase are: the phase file corresponding to the requirements summary extraction phase, the phase file corresponding to the code acquisition phase, and the phase file corresponding to the technical solution generation phase.

[0232] Furthermore, processing module 34 is specifically used for:

[0233] If, within a preset time period after sending the file storage path to the sub-agent corresponding to the software development stage, the corresponding stage file is received from the sub-agent, the stage status of the software development stage is updated to "completed".

[0234] Furthermore, module 31 is also used for:

[0235] If the corresponding stage file for the software development stage is not received from the sub-agent within a preset time after sending the file storage path, the target file is obtained according to the file storage path, and the current running result of the sub-agent is obtained.

[0236] Processing module 34 is also used for:

[0237] Based on the current running results and target files, generate the phase files corresponding to the software development phase, or generate the phase files and target software corresponding to the software development phase.

[0238] Update the phase status of the software development phase to "completed".

[0239] Furthermore, the stage file of the code acquisition stage includes at least one code identifier, as well as the code and code type corresponding to each code identifier, wherein the code type is front-end code or back-end code;

[0240] The phase files for the software generation phase include identifiers of modified code;

[0241] After updating the phase status of the software development phase to "completed", the sending module 32 is also used to send a coverage check request to the test sub-agent if the code type corresponding to all modified code identifiers includes backend code, so that the test sub-agent can obtain the target coverage, generate a coverage test result indicating whether the coverage test has passed based on the target coverage and the preset coverage threshold, and send the coverage test result to the main agent.

[0242] The receiving module 33 is also used to determine whether the coverage test result indicates that the coverage test has passed when it receives the coverage test result sent by the test sub-agent;

[0243] The processing module 34 is also used to generate a software development report based on the software requirements document, the coverage test results, and the phase document of each sub-agent if the coverage test results indicate that the coverage test has passed.

[0244] Furthermore, the sending module 32 is also used for:

[0245] If the coverage test result indicates that the coverage test failed, a software repair request is sent to the repair sub-agent so that the repair sub-agent can obtain the repair test case file, test the target software according to the repair test case file, store the target coverage, and send the repair test case file to the main agent.

[0246] When the receiving module 33 receives the repair test case file, it sends a coverage check request to the test sub-agent so that the test sub-agent can obtain the target coverage, generate coverage test results based on the target coverage and the preset coverage threshold, and send the coverage test results to the main agent.

[0247] The receiving module 33 is also used to determine whether the coverage test result indicates that the coverage test has passed when it receives the coverage test result sent by the test sub-agent;

[0248] The processing module 34 is also used to repeat the above steps if the coverage test result indicates that the coverage test has failed, until the coverage test result indicates that the coverage test has passed, and then generate a software development report based on the software requirements document, the coverage test result, the repair test case file, and the phase file of each sub-agent.

[0249] Furthermore, processing module 34 is also used for:

[0250] If the code type corresponding to all modified code identifiers does not include backend code, generate a coverage test skip file and store it.

[0251] A software development report is generated based on the coverage test skip file, the software requirements file, and the phase file for each sub-agent.

[0252] Furthermore, processing module 34 is specifically used for:

[0253] If a coverage test result is received from the test sub-agent within a preset time after sending a coverage check request, it is determined whether the coverage test result indicates that the coverage test has passed.

[0254] Furthermore, processing module 34 is also used for:

[0255] If no coverage test result is received from the test sub-agent within a preset time after sending a coverage check request, the target coverage is obtained, and a coverage test result indicating whether the coverage test has passed is generated based on the target coverage and the preset coverage threshold.

[0256] Furthermore, the sending module 32 is specifically used for:

[0257] If a repair test case file is received from the repair sub-agent within a preset time after sending a software repair request to the repair sub-agent, then a coverage check request is sent to the test sub-agent.

[0258] Furthermore, the acquisition module 31 is also used to acquire the repair test case file based on the current running result of the acquisition repair sub-intelligent agent if no repair test case file is received from the repair sub-intelligent agent within a preset time after sending the software repair request to the repair sub-intelligent agent;

[0259] Processing module 34 is also used to test the target software based on the repair test case file to obtain the target coverage; and to store the repair test case file and the target coverage.

[0260] The sending module 32 is also used to send a coverage check request to the test sub-agent.

[0261] The software development apparatus provided in this embodiment is used to execute the technical solution of the main intelligent agent in any of the aforementioned method embodiments. Its implementation principle and technical effect are similar, and will not be described again here.

[0262] Figure 4 This is a schematic diagram of the structure of Embodiment 2 of the software development apparatus provided in this application; as shown below. Figure 4 As shown, the software development apparatus 40 includes:

[0263] Receiver module 41 is used to receive the file storage path sent by the main intelligent agent;

[0264] Processing module 42 is used for:

[0265] Retrieve the target file based on the file storage path;

[0266] Run the program based on the target file to generate stage files, or generate stage files and target software. Stage files and target software correspond to the software development stages in the software development process. Software development stages include the requirements summary extraction stage, code acquisition stage, technical solution generation stage, or software generation stage.

[0267] The sending module 43 is used to send the stage file to the main intelligent agent.

[0268] The software development apparatus provided in this embodiment is used to execute the technical solution of the sub-intelligent agent in any of the aforementioned method embodiments. Its implementation principle and technical effect are similar, and will not be described again here.

[0269] Figure 5 A schematic diagram of the structure of an electronic device provided in this application Figure 1 .like Figure 5 As shown, the electronic device 50 includes:

[0270] Processor 51, memory 52, and communication interface 53;

[0271] Memory 52 is used to store executable instructions of processor 51;

[0272] The processor 51 is configured to execute the technical solution of the main intelligent agent in any of the foregoing method embodiments by executing executable instructions.

[0273] Optionally, the memory 52 can be either standalone or integrated with the processor 51.

[0274] Optionally, when the memory 52 is a device independent of the processor 51, the electronic device 50 may further include:

[0275] Bus 54, memory 52 and communication interface 53 are connected to processor 51 through bus 54 and complete communication with each other. Communication interface 53 is used to communicate with other devices.

[0276] Optionally, the communication interface 53 can be implemented using a transceiver. The communication interface is used to enable communication between the database access device and other devices (e.g., clients, read-write databases, and read-only databases). The memory may include random access memory (RAM) and may also include non-volatile memory, such as at least one disk drive.

[0277] Bus 54 can be a Peripheral Component Interconnect (PCI) bus or an Extended Industry Standard Architecture (EISA) bus, etc. Buses can be categorized as address buses, data buses, control buses, etc. For ease of representation, only one thick line is used in the diagram, but this does not indicate that there is only one bus or one type of bus.

[0278] The processors mentioned above can be general-purpose processors, including central processing units (CPUs), network processors (NPs), etc.; they can also be digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or other programmable logic devices, discrete gate or transistor logic devices, or discrete hardware components.

[0279] The electronic device is used to execute the technical solution of the main intelligent agent in any of the aforementioned method embodiments. Its implementation principle and technical effect are similar, and will not be described again here.

[0280] Figure 6 A schematic diagram of the structure of an electronic device provided in this application Figure 2 .like Figure 6 As shown, the electronic device 60 includes:

[0281] Processor 61, memory 62, and communication interface 63;

[0282] Memory 62 is used to store executable instructions of processor 61;

[0283] The processor 61 is configured to execute the technical solution of the sub-agent in any of the foregoing method embodiments by executing executable instructions.

[0284] Optionally, the memory 62 can be either standalone or integrated with the processor 61.

[0285] Optionally, when the memory 62 is a device independent of the processor 61, the electronic device 60 may further include:

[0286] Bus 64, memory 62 and communication interface 63 are connected to processor 61 through bus 64 and complete communication with each other. Communication interface 63 is used to communicate with other devices.

[0287] Optionally, the communication interface 63 can be implemented using a transceiver. The communication interface is used to enable communication between the database access device and other devices (e.g., clients, read-write databases, and read-only databases). The memory may include random access memory (RAM) and may also include non-volatile memory, such as at least one disk drive.

[0288] Bus 64 can be a Peripheral Component Interconnect (PCI) bus or an Extended Industry Standard Architecture (EISA) bus, etc. Buses can be categorized as address buses, data buses, control buses, etc. For ease of representation, only one thick line is used in the diagram, but this does not indicate that there is only one bus or one type of bus.

[0289] The processors mentioned above can be general-purpose processors, including central processing units (CPUs), network processors (NPs), etc.; they can also be digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or other programmable logic devices, discrete gate or transistor logic devices, or discrete hardware components.

[0290] The electronic device is used to execute the technical solution of the sub-intelligent agent in any of the aforementioned method embodiments. Its implementation principle and technical effect are similar, and will not be described again here.

[0291] Figure 7 This is a schematic diagram of the structure of a software development system provided in this application. Figure 7 As shown, the software development system includes:

[0292] The main intelligent agent 71 and the sub-intelligent agents corresponding to each stage of the software development process, including the sub-intelligent agent 72 corresponding to the requirement summary extraction stage, the sub-intelligent agent 73 corresponding to the code acquisition stage, the sub-intelligent agent 74 corresponding to the technical solution generation stage, and the sub-intelligent agent 75 corresponding to the software generation stage.

[0293] The main intelligent agent is used to execute the technical solution of the main intelligent agent in any of the aforementioned method embodiments. Its implementation principle and technical effect are similar, and will not be repeated here.

[0294] The sub-agent is used to execute the technical solution of the sub-agent in any of the aforementioned method embodiments. Its implementation principle and technical effect are similar, and will not be repeated here.

[0295] This application also provides a readable storage medium storing a computer program thereon, which, when executed by a processor, implements the technical solutions provided in any of the foregoing method embodiments.

[0296] This application also provides a computer program product, including a computer program, which, when executed by a processor, is used to implement the technical solutions provided in any of the foregoing method embodiments.

[0297] Those skilled in the art will understand that all or part of the steps of the above-described method embodiments can be implemented by hardware related to program instructions. The aforementioned program can be stored in a computer-readable storage medium. When executed, the program performs the steps of the above-described method embodiments; and the aforementioned storage medium includes various media capable of storing program code, such as ROM, RAM, magnetic disks, or optical disks.

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

Claims

1. A software development method, characterized in that, Applied to the main intelligent agent, the method includes: Obtain the software requirements document; For each software development stage in the software development process, when the preset trigger condition of the software development stage is met, the target file corresponding to the software development stage is determined according to the software requirements file or the received stage file; the file storage path of the target file is sent to the sub-agent corresponding to the software development stage; the software development stage is a requirements summary extraction stage, code acquisition stage, technical solution generation stage, or software generation stage; the sub-agent is used to generate the stage file corresponding to the software development stage according to the target file; For each software development stage, receive the stage file corresponding to the software development stage sent by the sub-agent corresponding to that software development stage.

2. The method according to claim 1, characterized in that, When the software requirements file is obtained, the method further includes: storing the software requirements file and determining the stage status of each software development stage as not started; For each software development stage, when the preset triggering condition of the software development stage is met, the method further includes: updating the stage status of the software development stage to in progress; For each software development stage, upon receiving the stage file corresponding to the software development stage sent by the sub-agent corresponding to the software development stage, the method further includes: updating the stage status of the software development stage to "completed".

3. The method according to claim 2, characterized in that, The preset trigger condition for the requirement summary extraction stage is that the software requirement file has been stored. The preset triggering condition for the code acquisition stage is that the stage status of the requirement summary extraction stage is completed. The preset triggering condition for the technical solution generation stage is that the stage status of the code acquisition stage is completed; The preset trigger condition for the software generation stage is that the stage status of the technical solution generation stage is completed.

4. The method according to claim 2, characterized in that, For each software development stage, when receiving the stage file corresponding to the software development stage sent by the sub-agent corresponding to the software development stage, the method further includes: storing the stage file; The target file corresponding to the requirements summary extraction stage is: the software requirements file; The target file corresponding to the code acquisition phase is the phase file corresponding to the requirement summary extraction phase. The target files corresponding to the technical solution generation stage are: the stage file corresponding to the requirement summary extraction stage, and the stage file corresponding to the code acquisition stage; The target files corresponding to the software generation stage are: the stage file corresponding to the requirement summary extraction stage, the stage file corresponding to the code acquisition stage, and the stage file corresponding to the technical solution generation stage.

5. The method according to claim 2, characterized in that, The step of updating the phase status of the software development phase to "completed" includes: If, within a preset time period after sending the file storage path to the sub-agent corresponding to the software development stage, the stage status of the software development stage is received from the sub-agent, the stage status of the software development stage is updated to "completed".

6. The method according to claim 5, characterized in that, The method further includes: If, within a preset time period after sending the file storage path to the sub-agent corresponding to the software development stage, the stage file corresponding to the software development stage is not received from the sub-agent, then the target file is obtained according to the file storage path, and the current running result of the sub-agent is obtained. Based on the current running results and the target file, generate the stage file corresponding to the software development stage, or generate the stage file and target software corresponding to the software development stage. Update the phase status of the software development phase to "completed".

7. The method according to any one of claims 2 to 5, characterized in that, The stage file of the code acquisition stage includes at least one code identifier, as well as the code and code type corresponding to each code identifier, wherein the code type is front-end code or back-end code; The phase files for the software generation phase include modified code identifiers; The method for updating the phase status of the software development phase to "completed" further includes: If all the code types corresponding to the modified code identifiers include backend code, a coverage check request is sent to the test sub-agent so that the test sub-agent can obtain the target coverage, generate a coverage test result indicating whether the coverage test has passed based on the target coverage and a preset coverage threshold, and send the coverage test result to the main agent. Upon receiving the coverage test result sent by the test sub-agent, determine whether the coverage test result indicates that the coverage test has passed; If the coverage test result indicates that the coverage test has passed, a software development report is generated based on the software requirements document, the coverage test result, and the phase document for each sub-agent.

8. The method according to claim 7, characterized in that, The method further includes: If the coverage test result indicates that the coverage test has failed, a software repair request is sent to the repair sub-agent so that the repair sub-agent can obtain the repair test case file, test the target software according to the repair test case file, obtain the target coverage and store it, and then send the repair test case file to the main agent. Upon receiving the repair test case file, a coverage check request is sent to the test sub-agent to enable the test sub-agent to obtain the target coverage, generate coverage test results based on the target coverage and a preset coverage threshold, and send the coverage test results to the main agent; Upon receiving the coverage test result sent by the test sub-agent, determine whether the coverage test result indicates that the coverage test has passed; If the coverage test result indicates that the coverage test failed, repeat the above steps until the coverage test result indicates that the coverage test passed. Then, generate a software development report based on the software requirements document, the coverage test result, the repair test case file, and the phase file for each sub-agent.

9. The method according to claim 7, characterized in that, The method further includes: If the code type corresponding to all modified code identifiers does not include backend code, generate a coverage test skip file and store it. A software development report is generated based on the coverage test skip file, the software requirements file, and the phase file for each sub-agent.

10. The method according to claim 7, characterized in that, When the coverage test result is received from the test sub-agent, determining whether the coverage test result indicates that the coverage test has passed includes: If, within a preset time period after sending a coverage check request to the test sub-agent, the coverage test result is received from the test sub-agent, then it is determined whether the coverage test result indicates that the coverage test has passed.

11. The method according to claim 10, characterized in that, The method further includes: If the coverage test result is not received from the test sub-agent within a preset time after sending the coverage check request, the target coverage is obtained, and a coverage test result indicating whether the coverage test has passed is generated based on the target coverage and a preset coverage threshold.

12. The method according to claim 8, characterized in that, Upon receiving the repaired test case file, a coverage check request is sent to the test sub-agent, including: If, within a preset time period after sending a software repair request to the repair sub-agent, the repair test case file is received from the repair sub-agent, then a coverage check request is sent to the test sub-agent.

13. The method according to claim 12, characterized in that, The method further includes: If the repair test case file is not received from the repair sub-agent within a preset time after sending the software repair request to the repair sub-agent, then the repair test case file is obtained based on the current running result of the repair sub-agent, and the target software is tested based on the repair test case file to obtain the target coverage. The repair test case file and the target coverage are stored, and a coverage check request is sent to the test sub-agent.

14. A software development method, characterized in that, The method applies to sub-agents corresponding to each software development stage in the software development process, wherein the software development stage is the requirement summary extraction stage, code acquisition stage, technical solution generation stage, or software generation stage. Receive the file storage path sent by the main intelligent agent; Obtain the target file based on the file storage path; Run the program according to the target file to generate the phase file corresponding to the software development phase, or generate the phase file and target software corresponding to the software development phase. The phase file corresponding to the software development phase is sent to the main intelligent agent.

15. A software development apparatus, characterized in that, include: The acquisition module is used to acquire software requirements documents. The sending module is used to, for each software development stage in the software development process, when a preset trigger condition for the software development stage is met, determine the target file corresponding to the software development stage based on the software requirements file or the received stage file; and send the file storage path of the target file to the sub-agent corresponding to the software development stage; wherein the software development stage is a requirements summary extraction stage, code acquisition stage, technical solution generation stage, or software generation stage; and the sub-agent is used to generate the stage file corresponding to the software development stage based on the target file. The receiving module is used to receive, for each software development stage, a stage file corresponding to that software development stage sent by the sub-agent corresponding to that software development stage.

16. A software development apparatus, characterized in that, include: The receiving module is used to receive the file storage path sent by the main intelligent agent; Processing module, used for: Obtain the target file based on the file storage path; Run the program based on the target file to generate a stage file, or generate a stage file and the target software; the stage file and the target software correspond to the software development stage in the software development process, and the software development stage is the requirement summary extraction stage, the code acquisition stage, the technical solution generation stage, or the software generation stage; The sending module is used to send the stage file to the main intelligent agent.

17. An electronic device, characterized in that, include: Processor, memory, communication interface; The memory is used to store the executable instructions of the processor; The processor is configured to execute the software development method according to any one of claims 1 to 13 by executing the executable instructions.

18. An electronic device, characterized in that, include: Processor, memory, communication interface; The memory is used to store the executable instructions of the processor; The processor is configured to execute the software development method of claim 14 by executing the executable instructions.

19. A software development system, characterized in that, include: The main intelligent agent and the sub-intelligent agents corresponding to each stage of software development in the software development process; The main intelligent agent is used to execute the software development method according to any one of claims 1 to 13; The sub-agent is used to execute the software development method of claim 14.

20. A readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by a processor, it implements any one of claims 1 to 13, or the software development method of claim 14.

21. A computer program product, characterized in that, Includes a computer program, which, when executed by a processor, is used to implement any one of claims 1 to 13, or the software development method of claim 14.

Images