Code processing method and apparatus, electronic device, and storage medium

Abstract

This application provides a code processing method, apparatus, electronic device, and storage medium. The method includes obtaining first requirement information, and invoking an intelligent agent to generate a skeleton configuration description language based on the first requirement information and a first prompt word; displaying a first directory framework corresponding to the skeleton configuration description language, and generating a second directory framework based on received editing operations on the first directory framework; and invoking an intelligent agent to generate a form configuration description language corresponding to each form based on each form in the second directory framework, the first requirement information, and a second prompt word. This method can improve code development efficiency.

Description

Technical Field

[0001] This application relates to the field of artificial intelligence technology, and in particular to a code processing method, apparatus, electronic device, and storage medium. Background Technology

[0002] As enterprises across various industries continue to deepen their digital transformation, the development needs for enterprise-level business applications are characterized by a large number of applications, rapid iterations, and fragmented scenarios. Traditional code-based development models suffer from long development cycles, high technical barriers, and exorbitant customization costs, making them unsuitable for agile business development requirements. Low-code development platforms, relying on visual configuration and drag-and-drop component-based development models, significantly reduce the barriers to application building and shorten delivery cycles, and have now become a core technological support for enterprises to quickly deploy business systems and achieve digital transformation.

[0003] To further enhance the development efficiency and lower the barrier to entry of low-code platforms, existing technologies are beginning to incorporate large models and natural language interaction capabilities into low-code development scenarios, enabling the basic ability to automatically generate individual form components based on user natural language commands. However, currently, only one independent form can be generated from a single command, resulting in low code development efficiency. Summary of the Invention

[0004] The main purpose of this application is to provide a code processing method, apparatus, electronic device, and storage medium to improve code development efficiency.

[0005] To achieve the above objectives, this application proposes a code processing method, including: Obtain the first requirement information and call the intelligent agent to generate a skeleton configuration description language based on the first requirement information and the first prompt word; Display the first directory framework corresponding to the skeleton configuration description language, and generate the second directory framework based on the received editing operations on the first directory framework; The intelligent agent generates a form configuration description language for each form based on each form in the second directory framework, the first requirement information, and the second prompt word.

[0006] Optionally, in one implementation, the process of generating a skeleton configuration description language for the intelligent agent includes: Extract the application name based on the primary requirement information; Match a reference template based on the application name and primary requirement information; Generate a skeleton configuration description language based on the application name, primary requirement information, reference template, and primary prompt words.

[0007] Optionally, in one implementation, generating a second directory frame based on the received editing operations on the first directory frame includes: In response to multiple editing operations on the first directory frame, the modified first directory frame corresponding to each editing operation is displayed after each editing operation; In response to the received confirmation instruction, the final modified first directory frame is used as the second directory frame.

[0008] Optionally, in one implementation, after the calling agent generates a form configuration description language corresponding to each form based on each form in the second directory framework, the first requirement information, and the second prompt word, it further includes: Generate an application configuration description language based on skeleton configuration description language and form configuration description language; Application configuration description language based on an interactive canvas.

[0009] Optionally, in one implementation, after displaying the application configuration description language based on the interactive canvas, the method further includes: Obtain the second requirement information and invoke the intelligent agent to parse the second requirement information; When the second requirement information indicates that the application configuration description language should be modified, the agent is invoked to generate the incremental configuration description language corresponding to the application configuration description language based on the second requirement information.

[0010] Optionally, in one implementation, after invoking the agent to generate the incremental configuration description language corresponding to the application configuration description language based on the second requirement information, the method further includes: Demonstrates the incremental configuration description language; In response to the confirmation command for the incremental configuration description language, the application configuration description language is updated based on the incremental configuration description language.

[0011] Optionally, in one embodiment, after generating the second directory frame based on the received editing operations on the first directory frame, the method further includes: Perform structural validity and executability checks on the second directory framework, and display the check results.

[0012] This application also provides a code processing apparatus, comprising: The first generation unit is used to obtain the first requirement information and call the intelligent agent to generate a skeleton configuration description language based on the first requirement information and the first prompt word. The editing unit is used to display the first directory framework corresponding to the skeleton configuration description language, and generate the second directory framework based on the received editing operations on the first directory framework. The second generation unit is used to call the agent to generate a form configuration description language corresponding to each form based on each form in the second directory framework, the first requirement information, and the second prompt word.

[0013] Another aspect of this application provides an electronic device, comprising: Memory, transceiver, processor, and bus system; The memory is used to store programs; The processor is used to execute programs in memory, including methods for performing the aspects mentioned above; Bus systems are used to connect memory and processor to enable communication between them.

[0014] Another aspect of this application provides a computer-readable storage medium storing instructions that, when executed on a computer, cause the computer to perform the methods described above.

[0015] As can be seen from the above technical solutions, the embodiments of this application have the following advantages: By first calling the intelligent agent to generate a skeleton configuration description language based on the user's needs and prompts, the overall structure of the application can be planned in advance. After the user edits and optimizes the visual directory framework, the intelligent agent generates the corresponding form configuration description language for each form. The user's interactive editing of the directory framework can be used to align business requirements and generate form code that fits the overall application positioning, effectively reducing the workload of manually building the application framework and improving code development efficiency. Attached Figure Description

[0016] Figure 1 This is a schematic diagram of the application architecture of the code processing method provided in the embodiments of this application; Figure 2 This is a flowchart illustrating the code processing method provided in an embodiment of this application; Figure 3 This is a schematic diagram of the structure of the code processing device provided in the embodiments of this application; Figure 4 This is a schematic diagram of the structure of the electronic device provided in the embodiments of this application. Detailed Implementation

[0017] To make the objectives, technical solutions, and advantages of this application clearer, the following detailed description is provided in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative and not intended to limit the scope of this application.

[0018] It should be noted that although functional modules are divided in the device schematic diagram and a logical order is shown in the flowchart, in some cases, the steps shown or described may be performed in a different order than the module division in the device or the order in the flowchart. The terms "first," "second," etc., in the specification, claims, and the aforementioned drawings are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence.

[0019] The term “exemplary” as used herein means “serving as an example, embodiment, or illustration.” Any embodiment illustrated herein as “exemplary” is not necessarily to be construed as superior to or better than other embodiments.

[0020] In the embodiments of this application, the terms "module" or "unit" refer to a computer program or part of a computer program that has a predetermined function and works with other related parts to achieve a predetermined goal, and can be implemented wholly or partially using software, hardware (such as processing circuitry or memory), or a combination thereof. Similarly, a processor (or multiple processors or memory) can be used to implement one or more modules or units. Furthermore, each module or unit can be part of an overall module or unit that includes the functionality of that module or unit.

[0021] Furthermore, to better illustrate this application, numerous specific details are provided in the following detailed embodiments. Those skilled in the art should understand that this application can be implemented without certain specific details. In some instances, methods, means, components, and circuits well-known to those skilled in the art have not been described in detail in order to highlight the main points of this application.

[0022] Unless otherwise defined, all technical and scientific terms used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this application belongs. The terminology used herein is for the purpose of describing embodiments of this application only and is not intended to limit this application.

[0023] First, let's analyze some of the terms used in this application: A Domain-Specific Language (DSL) is a small, highly expressive programming language or data description language designed for a specific problem domain. Unlike general-purpose programming languages, DSLs focus on a specific range of tasks, with more concise syntax and a better understanding of the thinking habits of business users.

[0024] Milvus is an open-source vector database used for efficiently storing and retrieving vector embeddings generated by deep learning models to support AI applications such as similarity search and recommendation systems.

[0025] The Model Context Protocol (MCP) aims to provide a standardized, universal interface for large language models to interact with external data sources, tools, and services, addressing the fragmentation and high coupling issues when connecting AI models to real-world systems.

[0026] An intelligent agent is an AI entity that can autonomously perceive its environment, understand its goals, plan its actions, and invoke tools to execute tasks, completing complex workflows without the need for step-by-step human guidance.

[0027] Low-code development platforms are software development support platforms designed for rapid application building. They utilize visual configuration, drag-and-drop componentization, and modular assembly as their core development methods. They require little or no reliance on traditional hand-written code to enable page building, form design, process configuration, and logic orchestration for business applications. Through standardized components, unified configuration syntax, and a visual interactive interface, the platform shields the underlying technical implementation details, lowering the technical threshold for application development. It supports rapid deployment, flexible iteration, and on-demand expansion of various enterprise-level business applications, and is widely used in scenarios such as enterprise digital transformation and rapid deployment of business systems. It is a mainstream technology for improving software development efficiency and shortening delivery cycles.

[0028] On existing low-code development platforms, users can quickly build single forms using natural language. However, for complete applications containing multiple forms, manual creation remains a cumbersome and inefficient process. Furthermore, in actual use, users frequently face the need for continuous iteration of existing applications, groups, and forms. Traditional drag-and-drop configuration methods involve deep layers of operations and tedious steps, impacting code development efficiency.

[0029] Based on this, embodiments of this application provide a code processing method that can solve the above-mentioned technical problems.

[0030] System architecture and scenario description used in the embodiments of this application: Figure 1 This is a system architecture diagram applied to the code processing method according to an embodiment of this application. It includes a terminal 140, an Internet 130, a gateway 120, a server 110, etc.

[0031] Terminal 140 includes various forms of devices with display screens, such as desktop computers, laptops, PDAs (personal digital assistants), mobile phones, in-vehicle terminals, home theater terminals, dedicated terminals, intelligent voice interaction devices, smart home appliances, or aircraft. Furthermore, it can be a single device or a collection of multiple devices. Terminal 140 can communicate with the Internet 130 via wired or wireless means to exchange data.

[0032] Server 110 refers to a computer system that can provide certain services to terminal 140. Compared to ordinary terminal 140, server 110 has higher requirements in terms of stability, security, and performance. Server 110 can be a single high-performance computer in a network platform, a cluster of multiple high-performance computers, a portion of a single high-performance computer (e.g., a virtual machine), or a combination of portions of multiple high-performance computers (e.g., virtual machines).

[0033] Gateway 120, also known as an internetwork connector or protocol converter, is a computer system or device that acts as a translator, enabling network interconnection at the transport layer. It bridges the gap between two systems using different communication protocols, data formats, languages, or even completely different architectures. Gateways can also provide filtering and security functions. Messages sent from terminal 140 to server 110 are forwarded to the corresponding server 110 via gateway 120. Messages sent from server 110 to terminal 140 are also forwarded to the corresponding terminal 140 via gateway 120.

[0034] The code processing method provided in this application embodiment can be implemented separately in terminal 140, separately in server 110, or partially in terminal 140 and partially in server 110.

[0035] When the code processing method provided in this application embodiment is implemented alone in terminal 140, terminal 140 obtains first requirement information and calls an intelligent agent to generate a skeleton configuration description language based on the first requirement information and the first prompt word; terminal 140 displays a first directory framework corresponding to the skeleton configuration description language and generates a second directory framework based on the received editing operation on the first directory framework; terminal 140 calls an intelligent agent to generate a form configuration description language corresponding to each form based on each form in the second directory framework, the first requirement information, and the second prompt word.

[0036] The code processing method provided in the embodiments of this application will be described below with reference to the accompanying drawings. The execution subject of the code processing method described below is a terminal device, which can be implemented by the terminal device by running the various computer programs mentioned above. Of course, based on the understanding of the following text, it is not difficult to see that the code processing method provided in the embodiments of this application can also be implemented by the terminal device and the server in collaboration.

[0037] Please see Figure 2 ,like Figure 2 The diagram shown is a flowchart of a code processing method provided in this embodiment. The method includes: Step 201: Obtain the first requirement information and call the intelligent agent to generate the skeleton configuration description language based on the first requirement information and the first prompt word.

[0038] The first requirement information can be the original business requirements proposed by the user to guide the development of the business system. Here, it can be the overall business requirements for building the target low-code application, which are entered by the user in natural language.

[0039] An intelligent agent can be an intelligent execution unit built on a large language model, capable of receiving requirement information and prompt word constraints, and autonomously generating structured configuration text.

[0040] The first prompt word can be an instruction text used to constrain the output content, format, and logic of the artificial intelligence model. Here, it refers to a pre-set structured instruction used to guide the agent to generate the overall framework of the application, constraining the agent's output to include the overall architecture of grouping and form hierarchy.

[0041] The intelligent agent is invoked, and the collected first requirement information and the preset first prompt word are used as input. Based on the semantic parsing of the requirement and the logical constraints of the prompt word, the intelligent agent can generate domain-specific configuration text that represents the overall structure of the target application. This domain-specific configuration text can be called the skeleton configuration description language.

[0042] Step 202: Display the first directory framework corresponding to the skeleton configuration description language, and generate the second directory framework based on the received editing operations on the first directory framework.

[0043] The first directory framework can be a visual directory that represents the system's structural hierarchy. That is, after the application front-end parses and renders the skeleton configuration description language, it displays a visual structural view to the user that includes application groups and form names.

[0044] Editing operations can be interactive behaviors where users add, delete, modify, and adjust visual content. This includes business-level modifications such as adding, deleting, renaming, and adjusting the hierarchical order of groups and forms within the first directory framework. After the user completes the editing operations, the updated final application visual structure framework that meets the user's actual business expectations can be called the second directory framework.

[0045] Step 203: Invoke the intelligent agent to generate the form configuration description language corresponding to each form based on each form in the second directory framework, the first requirement information, and the second prompt word.

[0046] The second prompt can be a pre-set structured instruction used to guide the agent to generate detailed configurations for a single form, constraining the agent to call relevant functions to output detailed information such as form fields, controls, and validation rules. The domain-specific configuration text composed of this detailed information can be called a form configuration description language.

[0047] This application embodiment first calls an intelligent agent to generate a skeleton configuration description language based on the user's needs and prompts, thus realizing the pre-planning of the overall application structure. After the user edits and optimizes the visual directory framework, the intelligent agent then generates the corresponding form configuration description language for each form. By leveraging the user's interactive editing of the directory framework, business requirements can be aligned, generating form code that fits the overall application positioning, effectively reducing the workload of manually building the application framework and improving code development efficiency.

[0048] In one implementation, the process of generating a skeleton configuration description language for an intelligent agent includes: Extract the application name based on the primary requirement information; Match a reference template based on the application name and primary requirement information; Generate a skeleton configuration description language based on the application name, primary requirement information, reference template, and primary prompt words.

[0049] In this implementation, the application name can be a unique name used to identify the software application, which is the identifier name extracted by the agent from the first requirement information input by the user and used to characterize the business attributes of the target low-code application.

[0050] The reference template can be a reusable, standardized application structure sample, that is, a historical low-code application structure sample that is pre-stored in a vector database and is similar to the target application business scenario, which is used to provide a structural reference for the agent.

[0051] When generating the skeleton configuration description language, the agent first performs semantic parsing on the user's initial requirement information, extracting the application name that represents the target application's business type. Then, using the extracted application name and initial requirement information as retrieval criteria, it matches reference templates with similar business scenarios from a pre-defined template library, providing a structural reference for application framework generation. Finally, the application name, initial requirement information, matched reference templates, and initial prompts used to constrain the output format and logic are combined as input information. The agent, leveraging the reasoning capabilities of a large model, integrates the requirement semantics, template structure, and prompt constraints to generate the skeleton configuration description language representing the overall architecture of the target application. This generation process, through extracting application identifiers, matching similar templates, and combining hierarchical prompt constraints, achieves the transformation from natural language requirements to a standardized overall application framework, ensuring the business relevance and structural standardization of the skeleton configuration description language.

[0052] In one implementation, generating a second directory frame based on received editing operations on a first directory frame includes: In response to multiple editing operations on the first directory frame, the modified first directory frame corresponding to each editing operation is displayed after each editing operation; In response to the received confirmation instruction, the final modified first directory frame is used as the second directory frame.

[0053] In this implementation, when generating the second directory framework, users can perform multiple rounds of iterative editing of the first directory framework. The system responds to each editing operation in real time, synchronously updating and displaying the visual content of the first directory framework after each edit, realizing real-time preview and visual feedback of the editing process. When the user completes all structural adjustments and issues a confirmation command, the system receives the confirmation command and determines the modified first directory framework, which is finally formed after multiple rounds of editing, as the second directory framework. This completes the human-computer collaborative calibration of the overall application structure, ensuring that the overall application framework accurately matches the user's actual business needs. At the same time, the multi-round editing and adjustment method ensures the flexibility and adaptability of the application structure planning.

[0054] In one implementation, after the calling agent generates a form configuration description language corresponding to each form based on each form in the second directory framework, the first requirement information, and the second prompt word, the process further includes: Generate an application configuration description language based on skeleton configuration description language and form configuration description language; Application configuration description language based on an interactive canvas.

[0055] In this implementation, after the agent generates the form configuration description language for all forms, the system integrates and splices the skeleton configuration description language representing the overall application architecture with the form configuration description language corresponding to each form, generating an application configuration description language that can fully represent the overall structure of the target application and the details of each form. This application configuration description language can then be parsed and rendered onto an interactive front-end canvas, enabling a visual display of the complete low-code application. Users can view, adjust, and perform secondary development on the interactive canvas, further enhancing the convenience and interactivity of application building.

[0056] In one implementation, after displaying the application configuration description language based on the interactive canvas, the method further includes: Obtain the second requirement information and invoke the intelligent agent to parse the second requirement information; When the second requirement information indicates that the application configuration description language should be modified, the agent is invoked to generate the incremental configuration description language corresponding to the application configuration description language based on the second requirement information.

[0057] In this implementation, after the application configuration description language is visualized on the interactive canvas, the system supports supplementary requests from the user, i.e., second requirement information. Subsequently, an intelligent agent is invoked to perform semantic parsing of the second requirement information, clarifying the specific direction, content, and scope of the user's modification request. When the parsing determines that the intent of the second requirement information is to modify the already generated application configuration description language, the intelligent agent does not regenerate the complete application configuration description language. Instead, based on the structure and content of the existing application configuration description language and combined with the modification instructions of the second requirement information, it generates a structured configuration text that specifically contains the modified parts. This configuration text can be called the incremental configuration description language. This achieves partial iterative updates of the application configuration, ensuring the accuracy of the modifications while avoiding the efficiency loss caused by regenerating the complete configuration, further improving the flexibility and iteration efficiency of application building.

[0058] In one implementation, after invoking the agent to generate the incremental configuration description language corresponding to the application configuration description language based on the second requirement information, the method further includes: Demonstrates the incremental configuration description language; In response to the confirmation command for the incremental configuration description language, the application configuration description language is updated based on the incremental configuration description language.

[0059] In this implementation, the system displays the generated incremental configuration description language through a visual interface, allowing users to clearly see the specific modifications, the scope of modifications, and the impact of the modifications on the overall application structure. This ensures that users can intuitively understand the specific function of the incremental configuration and avoid blindly confirming modifications.

[0060] Once a user reviews the incremental configuration description language and confirms that the changes meet their needs and are accurate, they can issue a confirmation command. The system can then use this incremental description language to partially update the existing application configuration description language, replacing the parts that need modification and retaining the parts that do not require adjustment, ultimately generating the updated application configuration description language. This process of display, confirmation, and updating ensures the accuracy of incremental modifications.

[0061] In one implementation, after generating the second directory frame based on the received editing operations on the first directory frame, the method further includes: Perform structural validity and executability checks on the second directory framework, and display the check results.

[0062] In this implementation, after the user confirms and edits the second directory framework, the system can sequentially perform structural validity checks and executability checks on the second directory framework. The structural validity check verifies whether the grouping hierarchy, form attribution, and naming conventions conform to the low-code platform architecture rules, avoiding logical problems such as hierarchical confusion and incorrect form attribution. The executability check determines whether the directory framework can be correctly parsed and executed by the intelligent agent, form generation tool, and low-code engine, identifying potential risks such as missing structures and configuration conflicts in advance. After the checks are completed, the system can also visually display the results to the user. If any abnormalities are found, the user is prompted to correct them, ensuring the stability and reliability of the subsequent process of generating form configuration description languages ​​and building complete applications based on this directory framework. This avoids subsequent generation failures or application malfunctions due to non-standard framework structures, further improving the overall stability and controllability of the solution.

[0063] In one example, the execution process of the agent includes two types: intelligent building (generating new applications) and intelligent modification (incrementally updating existing applications).

[0064] Among them, intelligent construction: The system first performs semantic parsing on the natural language business requirements input by the user through a large model, extracts the application name corresponding to the target application, and feeds the extraction results back to the front end. The front end then creates an application instance based on the application name and generates a unique application identifier.

[0065] The knowledge base retrieval process then proceeds. Existing application templates and corresponding structured documents within the SaaS platform are pre-stored in the Milvus vector database. Each template contains standardized fields such as application name, application introduction, industry and application scenario, application description, and update log. During retrieval, the extracted application name is fused with the user's original requirement text using vector fusion query. The top three sets of reference templates with the highest similarity are returned. If no suitable template is found, an empty template is returned.

[0066] After completing the template retrieval, the user requirements, application name, matched knowledge base template, and preset output format requirements are input into the large model. The large model generates a structured description text of the directory framework to represent the overall structure of the application. The output content is strictly limited to a valid JSON string to ensure that group names and form names are clear and unambiguous.

[0067] The generated directory framework will be displayed visually on the front end, supporting multiple rounds of interactive editing by users. Users can modify group names, add or delete group structures, add or delete forms, adjust form names and business descriptions, and initiate commands to regenerate the directory framework according to actual needs.

[0068] After the user confirms the final directory framework, the system iterates through all forms within the framework, sequentially calls the MCP form generation tool, generates corresponding detailed form structured description text for each form, and finally integrates the directory framework description text with the detailed description text of each form to form a complete application structured description text and sends it to the front end. The front end dynamically parses and renders it into an interactive visual application canvas, realizing end-to-end automated construction from natural language requirements to a complete and operable low-code application.

[0069] Smart Modification: The system supports intelligent incremental modification of existing low-code applications, providing four standard modification operations: adding, deleting, modifying, and moving. These operations can respectively add groups or forms, delete invalid structures and forms, edit and update names and attributes, and adjust structural levels and positions, meeting various dynamic adjustment needs during application iteration.

[0070] To achieve precise operation positioning, the system can adopt a positioning mechanism based on name matching and unique identifier binding. Users can initiate modification commands through the natural language name description of the application, group, or form. The intelligent agent explicitly enters the complete structural information of the current application in the prompt words, including the identifier, name, type, and hierarchical relationship of all nodes. The large model is forced to perform target positioning and command output based on the existing unique identifier, ensuring that the modification operation is accurate and error-free.

[0071] The intelligent modification process follows a unified incremental modification configuration description language specification, employing standardized and universal data structures. It supports the definition of add, delete, modify, move, and non-executable operation types. It distinguishes between three types of operation objects: groups, forms, and controls, using target keys. Information such as identifiers, parent identifiers, names, attributes, and relative positions can be configured. Standard output examples are provided for each type of operation, and exception markers for non-executable operations are supported. The error message field explains the reason for the failure, facilitating front-end error notifications to the user. After the incremental modification configuration description language is generated, the front-end automatically generates a visual pre-modification card based on this language, intuitively displaying the changes to be executed and the operation results. Once the user confirms the modification command, the back-end executes the corresponding change operation according to the incremental modification configuration description language, completing a partial update of the original application configuration description language and achieving lightweight and highly efficient application iteration.

[0072] Code example for incrementally modifying the general structure of a DSL: json [{ "type": "add | edit | move | delete | non-executable", / / Operation type: add / edit / move / delete / non-executable "msg": "This operation is not feasible", / / Optional, only included when the operation is not feasible, to inform the user. "targetKey": "group | form | widget", / / Target type: group / form / control "data": { / / Detailed data of the target operation "group": { / / Used when the target is a group "id": "Unique identifier for the group", "parentId": "Parent group identifier", "name": "Group name"; }, "form": { / / Use when the target is a form "id": "Unique identifier for the form", "parentId": "Group ID", "name": "Form name"; }, "widget": { / / Used when the target is a control "id": "Unique identifier for the control", "parentId": "Identifier of the form to which the parent belongs", "name": "Control Name", "type": "Control type", "attrs": [{ / / List of control properties] "propertyKey": "property key name", "propertyValue": "property value", "dataType": "Data type", "description": "Attribute description"; }]; }; }, "position": { / / Optional, a description of the position used for adding or moving operations. "relativeId": "Reference Target Identifier", "type": "before | after | inner" / / Before / after / inside the target }}] Example code for adding a new group: json { "type": "add", / / Operation type: Add "targetKey": "group", / / Target of operation: grouping "data": { "group": { "id": "Sales Management ID", / / Unique identifier for newly added group "parentId": "Sales Management ID", / / Parent ID "name": "Sales Management" / / Group name } }, "position": { "relativeId": "Customer Management ID", / / Reference Target: Customer Management Group "insertType": "after" / / Insertion position: after }} Example code for deleting a form: json { "type": "delete", / / Operation type: delete "targetKey": "form", / / Target of operation: form "data": { "form": { "id": "User application form id", / / Unique identifier for the form to be deleted "parentId": "group_id", / / Identifier of the group to which it belongs "name": "User Application Form" / / Form Name } }} Code example for modifying group names: json { "operations": [{ "type": "edit", / / Operation type: Edit "targetKey": "group", / / Target of operation: grouping "data": { "group_id": "g2", / / Unique identifier for the target group "new_name": "Inventory Management" / / New name after modification } }]} Code example for a mobile form: json { "operations": [{ "type": "move", / / Operation type: move "targetKey": "form", / / Target of operation: form "data": { "form_id": "f5" / / Unique identifier for the form to be moved }, "position": { "targetGroupId": "g4" / / Unique identifier for the target group } }]} Example of code that cannot be executed: json { "type": "non-executable", / / Operation type: non-executable "msg": "The form cannot be moved inside another form", / / Error message "targetKey": "form" / / Target of operation: form} In one example, the overall system architecture can be divided into a user layer, an access layer, an intelligent agent layer, and a data layer. Each layer works together to complete the entire process of intelligent building and iterative modification of low-code applications. The user layer is a low-code designer interface for users, integrating a smart assistant input box, a canvas rendering area, and confirmation cards for incremental modification confirmation, enabling user input, application visual preview, and change confirmation interaction. The access layer uses an API gateway as the communication hub, uniformly handling request forwarding and data interaction between the front-end, back-end, and algorithm services, ensuring the security and stability of system interaction. The intelligent agent layer, as the processing unit, includes an intent parsing module, a planning module based on large model calls, a verification module for structural compliance verification, a template retrieval module that connects to the Milvus vector library, and a form generation tool that follows the MCP protocol. It can sequentially complete core intelligent tasks such as user requirement parsing, application framework planning, structural legality verification, similar template matching retrieval, and automated form configuration generation. The data layer provides full data support for the system. It persistently stores application structure domain-specific languages, form domain-specific languages, and user business data through a relational / document database. It stores vector data corresponding to various application templates according to the Milvus vector library to support similarity retrieval. At the same time, it uses a control metadata database to uniformly manage available control types and corresponding attribute information.

[0073] The above describes the code processing method; the following describes the device that executes the method.

[0074] Please see Figure 3 ,like Figure 3 The diagram shown is a structural schematic of a code processing device provided in an embodiment of this application. The device 300 includes: The first generation unit 301 is used to obtain the first requirement information and call the intelligent agent to generate a skeleton configuration description language based on the first requirement information and the first prompt word. Editing unit 302 is used to display the first directory framework corresponding to the skeleton configuration description language, and generate the second directory framework based on the received editing operation on the first directory framework; The second generation unit 303 is used to call the intelligent agent to generate a form configuration description language corresponding to each form based on each form in the second directory framework, the first requirement information, and the second prompt word.

[0075] Optionally, in one embodiment, the first generating unit 301 is specifically used for: Extract the application name based on the primary requirement information; Match a reference template based on the application name and primary requirement information; Generate a skeleton configuration description language based on the application name, primary requirement information, reference template, and primary prompt words.

[0076] Optionally, in one embodiment, the editing unit 302 is specifically used for: In response to multiple editing operations on the first directory frame, the modified first directory frame corresponding to each editing operation is displayed after each editing operation; In response to the received confirmation instruction, the final modified first directory frame is used as the second directory frame.

[0077] Optionally, in one embodiment, the second generating unit 303 is further configured to: Generate an application configuration description language based on skeleton configuration description language and form configuration description language; Application configuration description language based on an interactive canvas.

[0078] Optionally, in one embodiment, the second generating unit 303 is further configured to: Obtain the second requirement information and invoke the intelligent agent to parse the second requirement information; When the second requirement information indicates that the application configuration description language should be modified, the agent is invoked to generate the incremental configuration description language corresponding to the application configuration description language based on the second requirement information.

[0079] Optionally, in one embodiment, the second generating unit 303 is further configured to: Demonstrates the incremental configuration description language; In response to the confirmation command for the incremental configuration description language, the application configuration description language is updated based on the incremental configuration description language.

[0080] Optionally, in one embodiment, the editing unit 302 is further configured to: Perform structural validity and executability checks on the second directory framework, and display the check results.

[0081] This application also provides an electronic device, which includes a memory and a processor. The memory stores a computer program, and the processor executes the computer program to implement the above-described code processing method. This electronic device can be any smart terminal, including tablet computers, in-vehicle computers, etc.

[0082] Please see Figure 4 , Figure 4 The hardware structure of an electronic device according to another embodiment is illustrated. The electronic device includes: The processor 401 can be implemented using a general-purpose CPU (Central Processing Unit), microprocessor, application-specific integrated circuit (ASIC), or one or more integrated circuits, and is used to execute relevant programs to implement the technical solutions provided in the embodiments of this application. The memory 402 can be implemented as a read-only memory (ROM), a static storage device, a dynamic storage device, or a random access memory (RAM). The memory 402 can store the operating system and other applications. When the technical solutions provided in the embodiments of this specification are implemented through software or firmware, the relevant program code is stored in the memory 402 and is called and executed by the processor 401 using the code processing methods of the embodiments of this application. Input / output interface 403 is used to implement information input and output; The communication interface 404 is used to enable communication and interaction between this device and other devices. Communication can be achieved through wired means (such as USB, Ethernet cable, etc.) or wireless means (such as mobile network, WIFI, Bluetooth, etc.). Bus 405 transmits information between various components of the device (e.g., processor 401, memory 402, input / output interface 403, and communication interface 404); The processor 401, memory 402, input / output interface 403 and communication interface 404 are connected to each other within the device via bus 405.

[0083] This application also provides a computer-readable storage medium storing a computer program that, when executed by a processor, implements the above-described code processing method.

[0084] Memory, as a non-transitory computer-readable storage medium, can be used to store non-transitory software programs and non-transitory computer-executable programs. Furthermore, memory may include high-speed random access memory, and may also include non-transitory memory, such as at least one disk storage device, flash memory device, or other non-transitory solid-state storage device. In some embodiments, memory may optionally include memory remotely located relative to the processor, and these remote memories can be connected to the processor via a network. Examples of such networks include, but are not limited to, the Internet, intranets, local area networks, mobile communication networks, and combinations thereof.

[0085] The embodiments described in this application are for the purpose of more clearly illustrating the technical solutions of the embodiments of this application, and do not constitute a limitation on the technical solutions provided by the embodiments of this application. As those skilled in the art will know, with the evolution of technology and the emergence of new application scenarios, the technical solutions provided by the embodiments of this application are also applicable to similar technical problems.

[0086] Those skilled in the art will understand that the technical solutions shown in the figures do not constitute a limitation on the embodiments of this application, and may include more or fewer steps than shown, or combine certain steps, or different steps.

[0087] The device embodiments described above are merely illustrative. The units described as separate components may or may not be physically separate; that is, they may be located in one place or distributed across multiple network units. Some or all of the modules can be selected to achieve the purpose of this embodiment according to actual needs.

[0088] Those skilled in the art will understand that all or some of the steps in the methods disclosed above, as well as the functional modules / units in the systems and devices, can be implemented as software, firmware, hardware, or suitable combinations thereof.

[0089] The terms “first,” “second,” “third,” “fourth,” etc. (if present) in the specification and accompanying drawings of this application are used to distinguish similar objects and are not necessarily used to describe a specific 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 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.

[0090] It should be understood that in this application, "at least one (item)" means one or more, and "more than" means two or more. "And / or" is used to describe the relationship between related objects, indicating that three relationships can exist. For example, "A and / or B" can represent three cases: only A exists, only B exists, and both A and B exist simultaneously, where A and B can be singular or plural. The character " / " generally indicates that the preceding and following related objects are in an "or" relationship. "At least one (item) of the following" or similar expressions refer to any combination of these items, including any combination of single or plural items. For example, at least one (item) of a, b, or c can represent: a, b, c, "a and b", "a and c", "b and c", or "a and b and c", where a, b, and c can be single or multiple.

[0091] In the several embodiments provided in this application, it should be understood that the disclosed apparatus and methods can be implemented in other ways. For example, the apparatus embodiments described above are merely illustrative; for instance, the division of the units described above is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the coupling or direct coupling or communication connection shown or discussed may be through some interfaces; the indirect coupling or communication connection between apparatuses or units may be electrical, mechanical, or other forms.

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

[0093] Furthermore, the functional units in the various embodiments of this application can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit can be implemented in hardware or as a software functional unit.

[0094] If the integrated unit is implemented as a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, or all or part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes multiple instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods of the various embodiments of this application. The aforementioned storage medium includes various media capable of storing programs, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

[0095] The preferred embodiments of the present application have been described above with reference to the accompanying drawings, but this does not limit the scope of the claims of the present application. Any modifications, equivalent substitutions, and improvements made by those skilled in the art without departing from the scope and substance of the embodiments of the present application shall be within the scope of the claims of the present application.

Claims

1. A code processing method, characterized in that, include: Obtain the first requirement information and call the intelligent agent to generate a skeleton configuration description language based on the first requirement information and the first prompt word; The first directory framework corresponding to the skeleton configuration description language is displayed, and a second directory framework is generated based on the received editing operations on the first directory framework. The intelligent agent is invoked to generate a form configuration description language corresponding to each form based on each form in the second directory framework, the first requirement information, and the second prompt word.

2. The method according to claim 1, characterized in that, The process by which the intelligent agent generates the skeleton configuration description language includes: Extract the application name based on the first requirement information; A reference template is matched based on the application name and the first requirement information; The skeleton configuration description language is generated based on the application name, the first requirement information, the reference template, and the first prompt word.

3. The method according to claim 1, characterized in that, The step of generating a second directory frame based on the received editing operations on the first directory frame includes: In response to multiple editing operations on the first directory framework, the modified first directory framework corresponding to each editing operation is displayed after each editing operation; In response to the received confirmation instruction, the final modified first directory frame is used as the second directory frame.

4. The method according to claim 1, characterized in that, After the process of invoking the intelligent agent to generate a form configuration description language corresponding to each form based on each form in the second directory framework, the first requirement information, and the second prompt word, the process further includes: An application configuration description language is generated based on the skeleton configuration description language and the form configuration description language; The application configuration description language is displayed on an interactive canvas.

5. The method according to claim 4, characterized in that, After displaying the application configuration description language on an interactive canvas, the method further includes: Obtain the second requirement information and invoke the intelligent agent to parse the second requirement information; When the second requirement information indicates that the application configuration description language should be modified, the agent is invoked to generate an incremental configuration description language corresponding to the application configuration description language based on the second requirement information.

6. The method according to claim 5, characterized in that, After the process of invoking the intelligent agent to generate the incremental configuration description language corresponding to the application configuration description language based on the second requirement information, the method further includes: This demonstrates the incremental configuration description language; In response to the confirmation instruction for the incremental configuration description language, the application configuration description language is updated based on the incremental configuration description language.

7. The method according to claim 1, characterized in that, After generating the second directory framework based on the received editing operations on the first directory framework, the process further includes: Perform structural validity and executability checks on the second directory framework, and display the check results.

8. A code processing device, characterized in that, include: The first generation unit is used to obtain the first requirement information and call the intelligent agent to generate a skeleton configuration description language based on the first requirement information and the first prompt word. The editing unit is used to display the first directory framework corresponding to the skeleton configuration description language, and generate a second directory framework based on the received editing operation on the first directory framework. The second generation unit is used to call the intelligent agent to generate a form configuration description language corresponding to each form based on each form in the second directory framework, the first requirement information, and the second prompt word.

9. An electronic device, characterized in that, include: Memory, transceiver, processor, and bus system; The memory is used to store programs; The processor is configured to execute a program in the memory, including performing the method as described in any one of claims 1 to 7; The bus system is used to connect the memory and the processor to enable communication between the memory and the processor.

10. A computer-readable storage medium, characterized in that, Includes instructions that, when run on a computer, cause the computer to perform the method as described in any one of claims 1 to 7.

Images