A visual zero-code development platform building system

Abstract

This invention relates to the fields of cloud computing and software engineering technology, specifically a visual zero-code development platform construction system. Deployed on a cloud server, the system includes: a baseline state maintenance module for storing the current rendering state and initial abstract syntax tree (API) of the front-end visual interface; an intent parsing module for collecting concurrent operation data and using a large language model to identify target connected components and generate API update instructions; a topology reconstruction module for generating the target API and extracting dependencies; a coupling quantization module for calculating the visual logic coupling entropy value based on the number of cross-module state-sharing nodes and the closed-loop structure depth; a risk decision module for comparing the entropy value with the entropy carrying limit and generating risk hedging instructions or just-in-time (JIT) compilation instructions; and an adaptive execution module for executing target connected component locking, sandbox verification, or hot updates of the underlying code. This invention achieves controllable evolution under non-stop conditions.

Description

Technical Field

[0001] This invention relates to the fields of cloud computing and software engineering technology, specifically to a visual zero-code development platform construction system. Background Technology

[0002] Visual zero-code development platforms, as an important technical means for rapidly constructing business rules, have been widely used in scenarios such as financial risk control, approval processes, and credit verification. To ensure the flexibility of rule configuration and the efficiency of going live, business rule nodes are usually dragged, connected, and combined through a front-end visual interface, and the configuration results are synchronized to the cloud server and the business operation server for execution. In the case of frequent changes in regulatory policies and multiple business personnel concurrently modifying the rule chain, the platform not only needs to complete rule changes without downtime, but also needs to take into account the coordination between interface operation semantics, underlying logic topology, and operational stability.

[0003] However, when handling rule changes in visual no-code development platforms, existing methods mostly focus on directly generating the process structure based on front-end drag-and-drop results and performing immediate deployment. Risk is typically assessed roughly using the number of connections, the number of nodes added or removed, or fixed thresholds. For example, a common approach can be abstracted as: rule change risk value = number of state-sharing nodes + closed-loop depth, or directly determining whether to perform a hot update by setting a fixed threshold. While this calculation method can reflect rule complexity to some extent, it is difficult to accurately characterize the coupling risks caused by implicit state sharing, cross-module references, and potential back edges under concurrent editing conditions. Furthermore, fixed thresholds or simple weighting methods lack adaptability to changes in business time periods, system load fluctuations, and concurrent storm scenarios, easily leading to distorted risk assessment results. This not only affects the reliability of rule hot updates but may also cause interference between old and new rules and the spread of local changes into global logical anomalies. Summary of the Invention

[0004] The purpose of this invention is to provide a visual zero-code development platform building system to solve the following technical problems:

[0005] This avoids global logic failures caused by implicit state sharing between old and new rules, and makes it easier to establish a direct quantitative mapping between visual drag-and-drop actions and underlying logic risks, thereby achieving controllable evolution without downtime.

[0006] The objective of this invention can be achieved through the following technical solutions:

[0007] A visual zero-code development platform building system is deployed on a cloud server and communicates with a front-end visual interface and a business operation server via a network interface. It includes: a baseline state maintenance module, which stores the current rendering state of the front-end visual interface and the corresponding initial abstract syntax tree.

[0008] The intent parsing module collects concurrent operation data from the front-end visualization interface, uses a preset large language model to perform semantic parsing, identifies the target connection component, and generates an abstract syntax tree update instruction.

[0009] The topology reconstruction module reorganizes the initial abstract syntax tree according to the abstract syntax tree update instruction, generates the target abstract syntax tree, and extracts its directed acyclic graph dependencies.

[0010] The coupling quantization module extracts the number of cross-module state-sharing nodes and the depth of the closed-loop structure in the dependency relationship of the directed acyclic graph in order to calculate the visual logical coupling entropy value.

[0011] The risk decision module compares the visualization logic coupling entropy value with the preset entropy value carrying limit: if it is greater than or equal to the limit, a risk hedging instruction is generated; if it is less than the limit, an just-in-time compilation instruction is generated.

[0012] The adaptive execution module, in response to the risk hedging instruction, generates a visual degradation signal to lock the target connection component, and generates a logical isolation signal to inject into the sandbox running node in the business operation server. After verifying that there are no operational anomalies, the lock is released. In response to the just-in-time compilation instruction, it performs a hot update operation on the underlying code in the business operation server according to the target abstract syntax tree.

[0013] Preferably, the intent parsing module includes:

[0014] The feature extraction unit is used to extract features from the concurrent operation data to obtain the visual drag sequence and component connection relationship;

[0015] The intent inference unit is used to construct prompt words based on a preset zero-code component business dictionary, and input the visual drag sequence and the component connection relationship into the preset large language model in combination with the prompt words to output business intent text;

[0016] The instruction synthesis unit is used to convert the business intent text into a structured operation script and parse the structured operation script into the abstract syntax tree update instruction.

[0017] Preferably, the topology reconstruction module includes:

[0018] A node injection unit is used to inject temporary state variables and conditional branch nodes into the initial abstract syntax tree according to the abstract syntax tree update instruction, so as to generate the target abstract syntax tree;

[0019] Dependency traversal unit, used to perform depth-first traversal of the target abstract syntax tree to identify cross-module reference paths;

[0020] The graph construction unit is used to construct the directed acyclic graph dependency relationship based on the cross-module reference path.

[0021] Preferably, the coupled quantization module includes:

[0022] The state complexity calculation unit is used to count the number of cross-module state sharing nodes based on the dependency relationship of the directed acyclic graph, and multiply the number of cross-module state sharing nodes by a preset state weight coefficient to generate the state sharing complexity.

[0023] A cycle risk calculation unit is used to detect closed-loop structures in the dependencies of the directed acyclic graph and calculate the cycle dependency risk value based on the depth of the closed-loop structure.

[0024] The entropy fusion unit is used to perform a weighted summation of the state sharing complexity and the circular dependency risk value to output the visual logic coupling entropy value.

[0025] Preferably, the cycle risk calculation unit is used to detect closed-loop structures in the directed acyclic graph dependencies and calculate the cycle dependency risk value based on the depth of the closed-loop structures, specifically configured as follows:

[0026] If the depth of the closed-loop structure is greater than a preset depth threshold, a first risk weight coefficient is assigned to the closed-loop structure, and the depth of the closed-loop structure is multiplied by the first risk weight coefficient to obtain the circular dependency risk value.

[0027] If the depth of the closed-loop structure is less than or equal to the preset depth threshold, a second risk weight coefficient is assigned to the closed-loop structure, and the depth of the closed-loop structure is multiplied by the second risk weight coefficient to obtain the circular dependency risk value.

[0028] Wherein, the first risk weight coefficient is greater than the second risk weight coefficient.

[0029] Preferably, the adaptive execution module generates a visual degradation signal to lock the target connection component of the front-end visualization interface, including:

[0030] The permission downgrade unit is used to generate the visual downgrade signal based on the risk hedging instruction;

[0031] The interface reconstruction unit is used to respond to the visual degradation signal and downgrade the target connection component in the front-end visual interface from the advanced dynamic connection mode to the basic unidirectional connection mode.

[0032] An operation locking unit is used to intercept editing requests for the target connection component after it has been downgraded to the basic unidirectional connection mode, so as to lock the target connection component.

[0033] Preferably, the generation of logical isolation signals in the adaptive execution module to inject sandboxed runtime nodes into the business runtime server includes:

[0034] A sandbox creation unit is used to allocate independent memory space in the business operation server in response to the logical isolation signal to build an isolation sandbox;

[0035] A logical migration unit is used to compile the target abstract syntax tree into executable code and migrate the executable code to the isolation sandbox;

[0036] The status monitoring unit is used to run the executable code within the isolation sandbox and intercept the executable code's write operations to the preset global state machine in the business operation server.

[0037] Preferably, the hot update operation of the underlying code in the business execution server based on the target abstract syntax tree in the adaptive execution module includes:

[0038] An incremental compilation unit is used to compare the target abstract syntax tree with the initial abstract syntax tree in response to the just-in-time compilation instruction to generate incremental bytecode;

[0039] The memory replacement unit is used to replace the old version bytecode corresponding to the initial abstract syntax tree in the memory of the business running server with the incremental bytecode during system runtime, so as to complete the hot update operation of the underlying code.

[0040] Preferred options also include:

[0041] The concurrent storm monitoring module is used to collect the frequency of operation requests of the front-end visualization interface within a preset time window;

[0042] The dynamic frequency adjustment module is used to determine whether the frequency of the operation request is greater than a preset concurrent storm threshold; if the frequency of the operation request is greater than the concurrent storm threshold, a storm warning signal is generated to dynamically reduce the preset entropy carrying limit according to a preset attenuation step size; if the frequency of the operation request is less than or equal to the concurrent storm threshold, the current value of the preset entropy carrying limit is maintained.

[0043] Preferably, the front-end visual interface is a user interaction interface for configuring business rule nodes, and the concurrent operation data is a serialized data packet carrying timestamps and node coordinates.

[0044] The beneficial effects of this invention are:

[0045] 1. This invention utilizes a large language model to parse operational semantics to generate abstract syntax tree update instructions and reconstructs and extracts the dependencies of the directed acyclic graph; by quantifying and visualizing the entropy value of the logical coupling of the cross-module state sharing node number and closed-loop structure depth, it solves the problem that traditional methods are difficult to accurately assess implicit sharing risks and improves the accuracy of underlying topology risk assessment.

[0046] 2. This invention couples the visual logic with entropy values ​​and limits to output differentiated instructions; in case of high risk, it generates a visual degradation signal to lock the connection components and injects them into the sandbox to run nodes for isolation and verification; in case of low risk, it directly performs hot update operations on the underlying code based on the target abstract syntax tree, thus balancing the agility of rule changes and the stability of the global system without downtime.

[0047] 3. This invention collects the frequency of operation requests within a preset time window, and dynamically lowers the entropy value carrying limit according to a preset decay step size when the frequency exceeds the concurrent storm threshold. This adaptive mechanism overcomes the rigidity of fixed threshold evaluation, effectively buffers the impact of concentrated changes, and avoids global logic operation failures caused by multiple people editing new and old rules at high concurrency. Attached Figure Description

[0048] The invention will now be further described with reference to the accompanying drawings.

[0049] Figure 1 This is a schematic diagram of a visual zero-code development platform building system provided in an embodiment of this application. Detailed Implementation

[0050] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0051] Please see Figure 1 A visual zero-code development platform building system is deployed on a cloud server and communicates with the front-end visual interface and business operation server via a network interface. It includes: a baseline state maintenance module, which stores the current rendering state of the front-end visual interface and the corresponding initial abstract syntax tree.

[0052] The intent parsing module collects concurrent operation data from the front-end visual interface, uses a pre-set large language model to perform semantic parsing, identifies the target connection component, and generates an abstract syntax tree update instruction.

[0053] The topology reconstruction module reorganizes the initial abstract syntax tree based on the abstract syntax tree update instructions, generates the target abstract syntax tree, and extracts its directed acyclic graph dependencies.

[0054] The coupling quantization module extracts the number of cross-module state-sharing nodes and the depth of the closed-loop structure in the dependency relationship of the directed acyclic graph in order to calculate the visual logical coupling entropy value.

[0055] The risk decision-making module compares the visualized logic-coupled entropy value with the preset entropy value carrying limit: if it is greater than or equal to the limit, a risk hedging instruction is generated; if it is less than the limit, an just-in-time compilation instruction is generated.

[0056] The adaptive execution module responds to risk hedging instructions, generates visual degradation signals to lock the target connection components, and generates logical isolation signals to inject sandbox running nodes in the business operation server. After verifying that there are no operational anomalies, it releases the lock. It also responds to just-in-time compilation instructions and performs hot update operations on the underlying code in the business operation server according to the target abstract syntax tree.

[0057] This embodiment provides a mechanism for building a visual zero-code development platform system. Specifically, the system is applied to an enterprise-level financial risk control rule platform. When regulatory requirements are suddenly adjusted, multiple business personnel can simultaneously modify the credit verification node, quota control node, blacklist comparison node, and approval flow node in the front-end visual interface. The system needs to complete the rule change without stopping downtime, while avoiding global logic operation failures caused by implicit state sharing between the old and new rules.

[0058] Specifically, the baseline state maintenance module maintains a set of traceable construction baselines in the cloud server; the construction baseline includes at least two types of data: one is a snapshot of the current rendering state of the front-end visualization interface, and the other is the initial abstract syntax tree that corresponds one-to-one with the rendering state.

[0059] The aforementioned rendering state snapshot may include component identifier, coordinates, connection direction, component version number, and the business module to which it belongs; the aforementioned initial abstract syntax tree may include rule nodes, conditional branch nodes, state variable nodes, and call edges;

[0060] Preferably, the baseline state maintenance module records the abstract syntax tree after each successful release as a stable version. The current state of the interface that the business personnel are editing but have not yet published is recorded as the working version. This way, when high-risk connections are subsequently identified, the system can... Perform incremental analysis for security baselines without recalculating across all historical versions;

[0061] After receiving the concurrent operation data reported by the front end, the intent parsing module sorts the operation data by event-level time and merges it by user level. The concurrent operation data here can be a set of operations such as drag, snap, disconnect, reconnect, copy, and delete initiated by multiple users within the same time window.

[0062] In order to convert graphical actions into executable semantics, the system inputs the operation data into a preset language model. The model outputs not directly executable code, but a middle-layer business intent representation. For example, if one business person connects the abnormal transaction hit node to the manual review node, and another business person connects the high-net-worth client exemption node to the fast pass node, the model will generate business intent text such as "suspend approval if high-risk conditions are hit" and "bypass the standard review chain if exemption conditions are met".

[0063] The system then converts the text into an abstract syntax tree update instruction, such as adding conditional branches, inserting state variables, redirecting nodes, adding cross-module references, etc.

[0064] Upon receiving the abstract syntax tree update instruction, the topology reconstruction module performs node reorganization based on the initial abstract syntax tree to generate the target abstract syntax tree. ;

[0065] In a minimal sandbox simulation, assume the original rule chain is: Node Indicates credit limit verification, node This indicates a blacklist comparison, node This indicates automatic loan disbursement; the original dependency relationship is... When a business user adds a manual review node It also introduces shared state from the historical overdue profile module. At that time, the update may result in If an error occurs, proceed to... If it misses, continue until... ,at the same time and All read shared state ;

[0066] At this point, not only have new nodes been added to the target abstract syntax tree. Furthermore, cross-module state sharing relationships have emerged; the topology reconstruction module will continue to extract dependency edges and construct a directed acyclic graph dependency relationship for compilation and execution;

[0067] It should be noted that the embodiment requires both extracting the dependencies of the directed acyclic graph and identifying closed-loop structures; therefore, this embodiment adopts a method of separating the execution graph and the risk graph to handle this.

[0068] Specifically, when performing dependency expansion on the target abstract syntax tree, the system first identifies the set of candidate dependency edges. If a back edge is found, it is not directly incorporated into the directed acyclic graph used for execution. Instead, it is folded and recorded as an additional risk marker, and its backtracking path length is calculated as the depth of the closed loop structure. In this way, on the one hand, the directed acyclic graph dependency relationship that can be used for subsequent compilation scheduling is obtained, and on the other hand, the risk information of potential circular dependencies is retained for the coupling quantization module to call.

[0069] Furthermore, the extraction of the closed-loop structure depth in the directed acyclic graph dependency relationship mentioned below refers to reading the closed-loop information from the aforementioned additional risk markers associated with the directed acyclic graph dependency relationship, rather than re-incorporating the back edges into the execution graph itself; therefore, in this embodiment, the directed acyclic graph dependency relationship and the closed-loop structure depth correspond to the execution scheduling view and the risk assessment view, respectively, and both originate from the dependency expansion result of the same target abstract syntax tree;

[0070] The coupling quantization module calculates the visual logic coupling entropy value based on the aforementioned directed acyclic graph dependencies and their additional risk markers; preferably, the visual logic coupling entropy value... Composed of both state-sharing complexity and circular dependency risk, it can be expressed as:

[0071] in, This represents the complexity of state sharing. This represents the risk value of circular dependencies. and For preset weights, and Preset weights and The value is derived from logistic regression fitting of historical production environment failure samples; since deep circular dependencies have a higher probability of causing global failures, preferably, set... The value range is from 0.3 to 0.4. The value range is 0.6 to 0.7 to improve risk weighting; further, if the number of cross-module state sharing nodes is denoted as The state weight coefficients are denoted as Then it can be set as:

[0072] If the depth of the detected closed-loop structure is denoted as... Then the risk value of circular dependency can be expressed as:

[0073] in, The weighting coefficients correspond to the closed-loop risk; taking the aforementioned sandbox scenario as an example, if the number of newly added shared state nodes is 3, the state weighting coefficients are... ,but If an implicit backedge is detected that originates from the approval write-back status and then affects the credit limit verification in reverse, its closed-loop depth is 4, and the risk weight coefficient is... ,but ;when , When, the calculation formula is:

[0074] This value will be directly used as input for risk decision-making; the risk decision-making module will couple the visualization logic with the entropy value. With respect to the preset entropy carrying limit Perform a comparison;

[0075] when This indicates that seemingly simple front-end wiring changes have already created strong coupling at the underlying level. Immediate hot updates could easily propagate local risks into global failures, thus generating a risk hedging instruction. When this occurs, it indicates that the changes are still within the system's controllable range, and just-in-time compilation instructions are generated;

[0076] Preferably, the entropy carrying limit It is not a fixed constant, but can be dynamically configured according to system load and rule density; its dynamic configuration is specifically achieved through the following formula:

[0077] in, The system's preset basic load-bearing limit threshold; This represents the normalized combined memory and CPU load rate of the current system server, with a value ranging from 0 to 1. The rule density coefficient of the business module to which the target abstract syntax tree belongs is obtained by dividing the total number of existing nodes in the module by the upper limit of the standard module capacity.

[0078] and These are preset load penalty weights and density penalty weights, for example, using higher weights during peak trading hours. To output a lower threshold, use a lower threshold during off-peak periods. To output a higher threshold;

[0079] Meanwhile, to prevent the formula from calculating a negative load-bearing limit under extremely high loads or high regularity, which could lead to system anomalies, the system performs boundary checks before calculation, strictly limiting... as well as If there is an out-of-bounds situation, the coefficient of this part is treated as an extreme value close to 1 to ensure that the calculated entropy value carrying limit is always positive.

[0080] Furthermore, the threshold reduction after a concurrent storm is triggered in the implementation example can be seen as a refined implementation of the aforementioned dynamic configuration; that is, factors such as business hours and system load are used to form a basic threshold, while the concurrent storm monitoring results are used to perform additional contraction on top of this basic threshold. Both are consistent in scope and correspond to the same entropy carrying limit. The dynamic value acquisition process;

[0081] The adaptive execution module corresponds to two different execution paths. If a risk hedging instruction is received, the first step is to generate a visual degradation signal to lock the target connection component in the front end that causes high coupling, so that business personnel cannot continue to add high-risk connections at the visualization level.

[0082] The second step is to generate a logical isolation signal, inject a sandbox running node into the business running server, migrate the new logic corresponding to the target abstract syntax tree to the sandbox for verification, and release the front-end lock after it runs stably and does not trigger abnormal write operations, infinite loops or timeouts.

[0083] If a just-in-time compilation instruction is received, the system will directly perform hot updates of the underlying code based on the target abstract syntax tree to achieve real-time synchronization between the visual interface logic and the underlying code;

[0084] In engineering deployment, the sandbox running node can be represented as an isolated execution instance, an independent memory container, or a controlled virtual execution context in the business execution server, but they all point to the same logically isolated object, which does not change the technical meaning of injecting the sandbox running node in the embodiment.

[0085] As a further exception handling mechanism, this embodiment includes at least the following steps: First, if the concurrent operation data has missing timestamps, abnormal node coordinates, or conflicting component identifiers, the intent parsing module will not enter the language model inference, but will directly store the corresponding operation in the queue to be manually confirmed, and keep the current stable version unchanged.

[0086] Secondly, if the business intent text output by the language model cannot be mapped to the structured operation script, such as the presence of terms not found in the business dictionary, the system will revert to the predefined rule template matching mode, allowing only the execution of update instructions within the whitelist.

[0087] Third, if the topology reconstruction module discovers that a critical root node is missing, the main process is unreachable, or the number of dependent edges exceeds the upper limit when reconstructing the target abstract syntax tree, it will directly stop generating the target abstract syntax tree and generate a rollback instruction to restore to the previous state. Fourth, if an operational anomaly occurs during the verification process within the sandbox running node, the target connection component will not be unlocked, and the abnormal call chain, shared state set, and back edge path will be sent back to the front end for business personnel to correct.

[0088] For example, in the financial risk control rules platform, the regulatory authorities temporarily require the addition of a first-level manual review for high-frequency cross-border transactions; Business personnel A add an abnormal frequency judgment node to the transaction detection module, Business personnel B add a whitelist bypass to the customer exemption module, and Business personnel C adjust the status write-back strategy in the approval write-back module.

[0089] From the interface, the three elements appear to be only partially dragged and connected, but after semantic analysis, the system discovered that they all reference the same global customer risk profile status and may negatively influence the pre-judgment after the approval write-back; at this point, the coupled quantitative module calculates... If the entropy limit is exceeded, the risk decision module will not be directly hot-updated. Instead, it will first lock the relevant high-level connections and put the new logic into the sandbox node for trial run. After confirming that no state machine deadlock has occurred in the sandbox, the locks will be gradually released.

[0090] The purpose of this step is to establish a direct quantitative mapping between the visual drag-and-drop action and the underlying logical risks, so that the system no longer simply pursues immediate effect after modification, but first assesses the underlying coupling entropy in a high-concurrency and high-change environment, and then selects a hot update or risk hedging path, thereby achieving controllable evolution under the condition of no downtime.

[0091] In a preferred embodiment of the present invention, the intent parsing module includes: a feature extraction unit, used to extract features from concurrent operation data to obtain visual drag sequences and component connection relationships;

[0092] The intent inference unit is used to construct prompt words based on a preset zero-code component business dictionary, and combine the visual drag sequence and component connection relationship with the prompt words into a preset language model to output business intent text;

[0093] The instruction synthesis unit is used to convert business intent text into structured operation scripts and parse the structured operation scripts into abstract syntax tree update instructions.

[0094] The topology reconstruction module includes a node injection unit, which injects temporary state variables and conditional branch nodes into the initial abstract syntax tree according to the abstract syntax tree update instructions to generate the target abstract syntax tree;

[0095] The dependency traversal unit is used to perform a depth-first traversal of the target abstract syntax tree to identify cross-module reference paths; the graph construction unit is used to construct a directed acyclic graph dependency relationship based on the cross-module reference paths.

[0096] The coupling quantization module includes: a state complexity calculation unit, which is used to count the number of cross-module state-sharing nodes based on the dependency relationship of the directed acyclic graph, and multiply the number of cross-module state-sharing nodes by a preset state weight coefficient to generate the state-sharing complexity.

[0097] The cycle risk calculation unit is used to detect closed-loop structures in the dependencies of a directed acyclic graph and calculate the cycle dependency risk value based on the depth of the closed-loop structure; the entropy fusion unit is used to perform a weighted summation of the state sharing complexity and the cycle dependency risk value to output a visual logical coupling entropy value.

[0098] The cycle risk calculation unit is used to detect closed-loop structures in the dependencies of a directed acyclic graph and calculate the cycle dependency risk value based on the depth of the closed-loop structure. Specifically, if the depth of the closed-loop structure is greater than a preset depth threshold, a first risk weight coefficient is assigned to the closed-loop structure, and the depth of the closed-loop structure is multiplied by the first risk weight coefficient to obtain the cycle dependency risk value.

[0099] If the depth of the closed-loop structure is less than or equal to a preset depth threshold, a second risk weight coefficient is assigned to the closed-loop structure, and the depth of the closed-loop structure is multiplied by the second risk weight coefficient to obtain the circular dependency risk value; wherein, the first risk weight coefficient is greater than the second risk weight coefficient.

[0100] This embodiment provides a collaborative mechanism for semantic parsing, topology reconstruction, and coupling quantization. Specifically, relying solely on the general approach of immediately reconstructing and calculating entropy after dragging still presents two bottlenecks in scenarios where regulatory rules are centrally changed: First, there is ambiguity between front-end visual actions and back-end business semantics, and the same connection may represent sequential execution condition bypass or state write-back.

[0101] Secondly, even if the abstract syntax tree is reorganized, if the cross-module reference path and closed-loop depth are not further refined, the entropy value can only be roughly estimated and cannot support stable risk decisions. To solve the above problems, this embodiment introduces limited combined additional features to make intent parsing, node injection, graph construction and hierarchical risk weighting form a closed loop.

[0102] Specifically, the feature extraction unit extracts the visual drag sequence and component connection relationship from the concurrent operation data; the so-called visual drag sequence includes not only the starting component, the ending component and the drag trajectory, but also preferably the coordinate changes before and after dragging, snap events, undo / redo markers and the order of operation.

[0103] The component connection relationships describe the connection topology between components' input, output, conditional, and exception ends. For example, in a simplified scenario, if a user first drags the transaction frequency judgment node to the blacklist screening node, and then drags it from the exception exit of that node to the manual review node, the system can form a sequence. and connection relationships: ,

[0104] in, , and These correspond to the aforementioned transaction frequency judgment node, blacklist screening node, and manual review node, and are used only as node identifiers in the drag sequence. Compared to only recording the final connection status, this method can preserve the dynamic process of the user's operation intention, which is beneficial for distinguishing between the two different types of operations: re-layout and redefining business flow.

[0105] In the intent inference unit, the system constructs prompt words based on a preset zero-code component business dictionary; this business dictionary is not a general vocabulary, but is semantically bound to components within the enterprise rules platform. For example, terms such as hit exemption, block, suspend approval, write back credit, and freeze all correspond to predefined business actions and code templates.

[0106] The system inputs the visual drag sequence, component connection relationship and the aforementioned prompt words into the preset language model, so that the model outputs business intent text. In order to ensure the stability of the output of the large language model and the full disclosure of the calculation logic, the preset language model adopts a model that has been fine-tuned with a specific domain corpus. The sample pairs of the specific domain corpus include: the topological features of the historical drag sequence and connection relationship as input features, and the corresponding standard structured operation script as output labels.

[0107] Furthermore, the prompts include system role settings, few sample examples, and strict structured output format constraints. The structured output format must include at least four strongly validated mapping fields: action type, target component identifier, conditional expression, and state write-back key-value pair.

[0108] Here, it is preferable to use a Mermaid flowchart to detail the underlying logical flow and mapping process of visual action data, component dictionaries, and prompt word concatenation. Preferably, the business intent text output by the model uses a restricted template, such as when conditions... Actions to be executed upon establishment Otherwise, perform the action. and write back the state. This reduces the ambiguity caused by free text; the instruction synthesis unit maps business intent text into structured operation scripts; to ensure the accuracy and feasibility of the generated structured operation scripts, the system has a built-in standard action mapping dictionary table;

[0109] For example, if a high-frequency cross-border transaction is detected, the automatic loan disbursement and subsequent manual review can be converted into the following script semantics: Add a condition node. ;exist Insert branch to ;exist Saved to Simultaneously create state variables Record the review results; then parse the structured operation script into abstract syntax tree update instructions;

[0110] During the topology reconstruction phase, the node injection unit updates instructions according to the abstract syntax tree and inserts temporary state variables and conditional branch nodes into the initial abstract syntax tree;

[0111] The temporary state variables here are mainly used to handle the intermediate states of conditions added after semantic parsing, such as whether a special regulatory review is triggered or whether a high-priority customer is temporarily exempted; the conditional branch nodes are used to convert the graphical multi-exit connections into a compilable branch syntax structure.

[0112] The dependency traversal unit performs a depth-first traversal of the target abstract syntax tree to identify cross-module reference paths; for example, if the variables in the customer profiling module... If the transaction detection module and the approval module read the data simultaneously, and the approval result in turn affects the profile refresh node, then at least two cross-module reference paths will be identified in the traversal results.

[0113] The graph construction unit then generates directed acyclic graph dependencies based on these paths, and attaches the detected back edges to the corresponding node groups as risk metadata to prevent them from directly entering the execution graph. The risk metadata here is the same type of information carrier as the additional risk marker in the implementation method. Both are used to record back edges, backtracking paths and associated node groups that are not incorporated into the directed acyclic graph used for execution.

[0114] During the coupling quantization phase, the state complexity calculation unit counts the number of cross-module state-sharing nodes and multiplies it by the state weight coefficient to obtain the state-sharing complexity; this can be expressed as:

[0115] Specifically, if a state is accessed only by multiple nodes within the same business module, it is not considered cross-module sharing; if a state is accessed by two or more business modules simultaneously, it is counted as a shared node; to reflect the difference between core nodes and ordinary nodes, the state weight coefficient... It can be set according to node level, for example, giving higher weights to global state machine nodes and lower weights to temporary local states;

[0116] The loop risk calculation unit further processes the closed-loop structure depth; since the impact of shallow and deep back edges on system stability differs greatly, this embodiment provides a specific derivation of the scheme: Let the preset depth threshold be... The depth of the closed-loop structure is ;like Then assign the first risk weight coefficient. ;like Then assign a second risk weighting coefficient. ,and Therefore, the risk value of circular dependency is... This can be expressed as: when When, the calculation formula is:

[0117] when When, the calculation formula is:

[0118] For example, in a sandbox scene, if a local back edge of depth 2 is detected, and , ,but ;

[0119] If the depth of the other back edge is 5, and ,but Therefore, deep back edges significantly increase the risk score; the entropy fusion unit then weights and sums the state sharing complexity and circular dependency risk values, and its calculation formula is as follows:

[0120] When multiple closed loops exist simultaneously, the risk values ​​of each closed loop can be summed before being merged. The calculation formula is as follows:

[0121] Among them, subscript Used to identify the first One detected closed-loop structure This indicates that the first The risk value corresponding to each closed-loop structure;

[0122] To further explain, detecting the closed-loop structure in the dependency relationship of the directed acyclic graph, in this embodiment, specifically means: the cycle risk calculation unit reads the back edge risk metadata associated with the dependency relationship of the directed acyclic graph, performs backtracking path calculation on the candidate back edges, and thus obtains the depth of the closed-loop structure;

[0123] Therefore, the data source for loop closure detection corresponds to the dependency relationship of the directed acyclic graph, but the back edges are not rewritten back to the execution graph to avoid conflict with the process of generating the directed acyclic graph for execution by the aforementioned graph construction unit;

[0124] In one fault-tolerant implementation, if the feature extraction unit finds that only coordinate movement has occurred in the drag sequence without changing the component connection relationship, the intent inference unit can skip the model call and directly mark the operation as a pure interface rearrangement to avoid invalid calculations.

[0125] If a new component term does not exist in the business dictionary, the instruction synthesis unit will not generate new code logic, but will first downgrade the component to a general placeholder node and wait for the dictionary to be updated; if an isolated subtree is found during the depth-first traversal, that is, some nodes cannot be reached from the main entrance or the end point, the graph construction unit will record it as a dangling path and will not include it in the hot update candidate set.

[0126] If no closed-loop structure is detected, the circular dependency risk value is recorded as 0, and the entropy value is dominated by the state sharing complexity. Conversely, if a closed loop is detected but the depth cannot be reliably calculated, for example, if the path is corrupted or the node versions are inconsistent, the system directly uses the first risk weight coefficient for conservative estimation.

[0127] For example, in the same financial risk control platform, the regulatory authorities require double review of large cross-border transactions at night; business personnel drag four components—time window determination, amount threshold determination, manual review, whitelist exemption—into the canvas at the same time; after the feature extraction unit identifies the key drag sequence, it determines, in conjunction with the business dictionary, that the whitelist exemption belongs to the bypass component rather than the termination component. Therefore, the business intent text output by the language model is constrained to bypass manual review but retain the transaction record write-back when the exemption condition is met.

[0128] The node injection unit inserts a temporary state variable into the abstract syntax tree to record the reason for the exemption and adds a conditional branch; the dependency traversal unit finds that the exemption state is shared by both the approval module and the profiling module, and the approval write-back path can affect the time window strategy in reverse, thus forming a risk back edge with a depth of 4; according to the aforementioned threshold rule, the system adopts the first risk weight coefficient for this back edge, and finally obtains a higher coupling entropy value.

[0129] The purpose of this mechanism is to gradually implement front-end visual actions into an interpretable semantic script, a compilable abstract syntax tree, and a quantifiable dependency risk three-level intermediate representation, thereby improving the determinism of semantic parsing and giving the calculation of coupling entropy a clear data source and weighting basis.

[0130] In a preferred embodiment of the present invention, the adaptive execution module for generating visual degradation signals to lock the target connection component of the front-end visualization interface includes: a permission degradation unit, used to generate visual degradation signals based on risk hedging instructions;

[0131] The interface reconstruction unit is used to respond to the visual degradation signal and downgrade the target connection component in the front-end visual interface from the advanced dynamic connection mode to the basic unidirectional connection mode.

[0132] The operation locking unit is used to intercept editing requests for the target connection component after it has been downgraded to the basic unidirectional connection mode, so as to complete the locking of the target connection component.

[0133] The adaptive execution module generates a logical isolation signal to inject sandbox running nodes into the business execution server, including: a sandbox creation unit, which allocates independent memory space in the business execution server in response to the logical isolation signal to build an isolated sandbox;

[0134] The logic migration unit is used to compile the target abstract syntax tree into executable code and migrate the executable code to the isolation sandbox; the state monitoring unit is used to run the executable code in the isolation sandbox and intercept the executable code's write operations to the preset global state machine in the business running server.

[0135] The adaptive execution module performs hot update operations on the underlying code of the business execution server based on the target abstract syntax tree, including: an incremental compilation unit, which, in response to just-in-time compilation instructions, compares the target abstract syntax tree with the initial abstract syntax tree to generate incremental bytecode;

[0136] The memory replacement unit is used to replace the old version of bytecode corresponding to the initial abstract syntax tree in the memory of the business server with incremental bytecode during system runtime, so as to complete the hot update operation of the underlying code.

[0137] This embodiment provides a dynamic risk hedging and hot update coordination mechanism for the execution phase. Specifically, although the system can identify high coupling risks, if a single path is still used at the execution layer, a new bottleneck will appear: once all changes are simply blocked, the platform's agility will decrease significantly.

[0138] Conversely, if all changes are directly hot-updated, high-risk logic may penetrate into the production operation chain. To resolve this contradiction, this embodiment introduces three types of execution branches: visual degradation, logical isolation, and incremental hot update, enabling the system to perform differentiated processing according to the risk level.

[0139] Specifically, when the risk decision module outputs a risk hedging instruction, the permission downgrade unit generates a visual downgrade signal. This signal does not shut down the entire canvas, but precisely locates the target connection component that triggers high coupling. The aforementioned target connection component is usually manifested as a multi-exit dynamic connection, an advanced connector that can be reused across modules, or a special component that can trigger implicit state write-back.

[0140] After receiving a visual degradation signal, the interface reconstruction unit will downgrade the corresponding component from the advanced dynamic connection mode to the basic unidirectional connection mode. The so-called advanced dynamic connection mode refers to the connection form in which the component can switch between multiple targets according to conditions, supports reflow, and supports dynamic referencing of external states.

[0141] The so-called basic unidirectional connection mode only allows flow from a single source node to a single target node, and does not allow multiplexing or reverse write-back; the operation locking unit intercepts editing requests for degraded components, such as prohibiting dragging out abnormal exits again, prohibiting modification of fixed target ports, and prohibiting them from being promoted back to advanced mode; in this way, the system first converges high-risk structural degrees of freedom at the interface layer.

[0142] Visual degradation alone is insufficient to guarantee underlying stability, so the system further enters the logical isolation process; the sandbox creation unit responds to the logical isolation signal, allocates independent memory space in the business operation server, and builds an isolation sandbox; this sandbox is isolated from the production execution environment and preferably has an independent running context, object pool, and state mapping table; after the logical migration unit compiles the target abstract syntax tree into executable code, it does not directly load it into the production environment, but first migrates it to the isolation sandbox for execution;

[0143] The compilation here can generate script intermediate code, virtual machine bytecode, or other executable representations; the state monitoring unit runs the executable code in the sandbox and intercepts its write operations to the preset global state machine; for ease of review and understanding, this interception can be understood as allowing reads, restricting writes, and auditing writes, that is, the new logic can read the global business state for verification, but its writes to key state variables will be cached in the sandbox write set first and not immediately committed to the production environment;

[0144] The sandbox running node and the isolation sandbox are different descriptions of the same technical object: the former emphasizes its injection form in the business running server, while the latter emphasizes its running attribute of being isolated from the production execution environment. The two are not distinguished in this embodiment.

[0145] In a minimal sandbox simulation, suppose the logic for adding a new rule needs to be written into two global states: Indicates the customer's risk level. Indicates an approval freeze flag; the status monitoring unit can record a triplet for each write operation. ,in For the target global state, The value to be written, For timestamps;

[0146] If, during the verification period, the write set only contains idempotent updates to non-critical states, such as... Repeated writing to the same freeze marker indicates a low risk; if this occurs in the write set, first... Contradictory operations such as setting a high-risk position and then reverting it to a low-risk position from another branch, or exceeding a preset number of round-trip writes, can be considered potential state jitter and should not be allowed to unlock. Preferably, a sandbox anomaly score can be defined. The calculation formula is as follows:

[0147] in, This indicates the number of abnormal events that triggered the system alert log. This indicates the number of key global state machine write operations that were intercepted by the sandbox monitor. This indicates the number of milliseconds that the logic execution time within the sandbox exceeds the preset standard duration; , , The corresponding weighting factor is set according to the business tolerance level;

[0148] The aforementioned timestamps uniformly use symbols This indicates that the working version in the implementation method... Distinguish them by their subscript numbers; when If the threshold is exceeded, the verification is considered to have failed.

[0149] Corresponding to the risk hedging path, when the risk decision module outputs just-in-time compilation instructions, the system enters the hot update process; the incremental compilation unit performs a difference comparison between the target abstract syntax tree and the initial abstract syntax tree to generate incremental bytecode; the objects of the difference comparison include not only the addition, deletion and modification of nodes, but also the reconnection of edges, modification of condition expressions and changes in the state variable read and write sets;

[0150] For example, if only one condition node is added and one of the original branch exits is changed, there is no need to recompile all the business logic; only incremental bytecode needs to be generated for the affected subtree. The memory replacement unit replaces the old version bytecode corresponding to the initial abstract syntax tree in the memory of the business execution server with incremental bytecode during system runtime.

[0151] Preferably, the replacement process uses handle rebinding instead of forcibly restarting the thread. That is, a new version of the execution unit is generated first, and then the entry handle is switched from the old version to the new version. The old thread will exit naturally after completing the current request, thereby reducing the downtime window.

[0152] To avoid version conflicts caused by mutual overwriting of underlying code during hot updates, this embodiment can also employ version number verification; specifically, if the version number of the old version bytecode is... The parent version number on which the incremental bytecode is based must also be 0. If other users have already released a new version before the compilation is complete; If the current incremental package cannot be directly replaced due to inconsistency with the parent version, it needs to be re-uploaded. Perform difference calculations for the baseline; this process prevents multiple concurrent incremental packets from overwriting each other;

[0153] As a further exception handling mechanism, if the business personnel continue to initiate editing requests after the interface reconstruction unit has downgraded the target connection component, the operation locking unit can return to a read-only status prompt and save the modification intention in the draft area without affecting the production drawing; if the sandbox creation fails, for example, due to insufficient independent memory space allocation, the system will not allow high-risk logic by default and will keep the front end locked.

[0154] If compilation fails during the logic migration process, the logic will not be executed in the sandbox. Instead, the cause of failure will be located to the corresponding abstract syntax tree node. If the sandbox verification passes but the production environment changes the baseline version before unlocking, the differences between the sandbox logic and the latest stable version need to be compared again to prevent the verification results based on the old baseline from becoming invalid.

[0155] If, after entering the instant hot update path, the memory replacement unit detects that the old version of the code is still holding an uninterruptible long transaction, the new version will be put into a pending switch state first, and the replacement will be completed after the long transaction ends; if the waiting time exceeds the threshold, it will fall back to the sandbox verification path.

[0156] For example, in the new regulatory rules switching window of the financial risk control platform, business personnel added a rule that large cross-border transactions at night require manual review; the system calculated that the coupling entropy was high after the rule and the whitelist exemption approval write-back worked together, so it downgraded the corresponding connection component from the advanced dynamic connection mode with multiple branches to the basic one-way connection mode to prevent business personnel from continuing to add backflow connections on this path.

[0157] Meanwhile, the system creates an isolation sandbox in the business operation server, compiles the new rules, and processes a batch of mirrored transaction data in the sandbox first; the status monitoring unit finds that it only performs read-only access to the global customer risk level, and the write to the freeze mark also meets the idempotent condition, so the verification is passed and the front-end lock is released;

[0158] In contrast, when modifying another low-risk warning label, the system only generates a small amount of incremental bytecode and directly completes the memory replacement, achieving millisecond-level hot updates;

[0159] The purpose of this mechanism is to expand the binary choice of whether to take effect immediately into a layered execution strategy of interface convergence, logic isolation, and incremental hot update, so as to preserve business continuity during high-risk changes and at the same time prevent highly coupled logic from directly entering the production chain.

[0160] In a preferred embodiment of the present invention, it further includes: a concurrent storm monitoring module, used to collect the frequency of operation requests of the front-end visual interface within a preset time window;

[0161] The dynamic frequency adjustment module is used to determine whether the frequency of operation requests is greater than the preset concurrent storm threshold. If the frequency of operation requests is greater than the concurrent storm threshold, a storm warning signal is generated to dynamically reduce the preset entropy value carrying limit according to the preset attenuation step.

[0162] If the frequency of operation requests is less than or equal to the concurrent storm threshold, maintain the current value of the preset entropy carrying limit;

[0163] The front-end visual interface is the user interaction interface for configuring business rule nodes, and the concurrent operation data is a serialized data packet carrying timestamps and node coordinates.

[0164] This embodiment provides an adaptive entropy threshold adjustment mechanism for concurrent storm scenarios. Specifically, in the aforementioned implementation, the system is already able to calculate the visual logical coupling entropy value for single or partial changes. However, when new regulatory rules are issued centrally and multiple business departments modify rules simultaneously, a more subtle problem arises:

[0165] Even if each change, viewed individually, does not exceed the entropy carrying limit, the superposition of multiple changes in a short period of time may cause the entire system to quickly approach the boundary of cascading operation anomalies. To solve this problem, this embodiment introduces a concurrent storm monitoring module and a dynamic frequency adjustment module, and further defines the specific form of the front-end visualization interface and concurrent operation data, so that storm identification has a collectable data foundation.

[0166] Specifically, the front-end visual interface is a user interaction interface for configuring business rule nodes; each operation in this interface is encapsulated as a serialized data packet carrying a timestamp and node coordinates and uploaded to the cloud server; preferably, the serialized data packet includes at least the operation type, user identifier, canvas identifier, source node coordinates, target node coordinates, timestamp, component version and operation session identifier;

[0167] In this way, concurrent modifications by different users on different canvases can be uniformly included in time series analysis; since the node coordinates are preserved, the system can not only know who modified what, but also know which business area of ​​the canvas the modification occurred in, thereby further identifying whether local hot spots are being edited by multiple people at the same time.

[0168] The concurrency storm monitoring module counts the frequency of operation requests within a preset time window; let the number of serialized data packets received within this time window be... The time window duration is Then the frequency of operation requests The calculation logic is the number of packets divided by the time, which can be specifically expressed as:

[0169] For example, if 800 operation data packets are received within a 10-second window, then the frequency is... The system can further reduce the impact of instantaneous jitter by calculating the smoothing frequency using a sliding window method. For example, averaging the frequencies of the most recent windows according to their weights;

[0170] If only the current window value is used for judgment, storm warnings may be frequently triggered due to short-term peaks; introducing a smoothing frequency can improve the stability of threshold adjustment.

[0171] Preferably, the operation request frequency can be directly taken as the current window frequency. Alternatively, a smoothing frequency obtained based on multiple adjacent windows can be used. As a judgment value;

[0172] Regardless of which statistical value is used, the execution result of the dynamic frequency modulation module still follows the binary logic defined in the embodiment, that is, the threshold is lowered only when the judgment value is greater than the concurrent storm threshold, and the current entropy value carrying limit is kept unchanged when the judgment value is less than or equal to the concurrent storm threshold.

[0173] The dynamic frequency adjustment module determines whether the frequency of operation requests exceeds the preset concurrent storm threshold. ;like If this happens, a storm warning signal is generated, and the entropy carrying capacity is dynamically reduced according to a preset attenuation step size; let the original entropy carrying capacity be... The decay step size is Then in the first After the storm warning is triggered, it can be updated to:

[0174] in, This indicates the sequence number of times a storm warning has been triggered. This represents the minimum allowable entropy value limit of the system, used to prevent the threshold from decreasing indefinitely; if Then maintain the current value. ;

[0175] The essence of this adjustment method is: when a concurrent storm occurs, the system actively tightens the triggering conditions of just-in-time compilation instructions, so that more medium-risk changes are transferred to the risk hedging path; after the concurrency returns to normal, the system maintains the current threshold formed during the storm and waits for a reassessment in the subsequent time window, instead of automatically performing a rebound in this embodiment, so as to maintain consistency with the limitation of maintaining the current value in the embodiment.

[0176] To facilitate understanding, a sandbox simulation can be performed; assume that the system's default entropy carrying capacity is 10, the concurrent storm threshold is 50 times per second, the decay step size is 1.5, and the minimum threshold is 5.

[0177] If the frequency detected in the first time window is 42 times per second, which does not exceed the concurrent storm threshold, the entropy carrying limit remains at 10. If the frequency rises to 68 times per second in the second time window, the system triggers a storm warning and lowers the threshold to 8.5.

[0178] If the frequency further increases to 90 times per second within the third time window, the threshold will continue to decrease to 7. At this point, a rule change that originally had a coupling entropy of 7.8 can be directly hot-updated under normal circumstances, but will be judged as high-risk during a storm and will enter the visual degradation and sandbox isolation path. This threshold linkage is not because the change itself has become worse, but because the system as a whole is in a more vulnerable runtime state, and conservatism needs to be improved.

[0179] To further explain, the node coordinates in this embodiment mainly serve two purposes: first, to work with timestamps to reconstruct the area where concurrent editing occurred, thereby distinguishing between full canvas storms and local hotspot storms; second, to cluster operations in adjacent business areas within the same time window, avoiding misjudging spatially unrelated canvas operations as the same conflict cluster.

[0180] Preferably, when the timestamps of multiple serialized data packets are close and the node coordinates fall within the same business area boundary, the concurrent storm monitoring module can regard them as dense requests in the same hotspot area; when the times are close but the coordinates are scattered in multiple independent canvas blocks, only the global frequency is counted, and the local hotspot weight is not increased.

[0181] Through this supplementary processing, the serialized data packets carrying timestamps and node coordinates not only exist as the upload format, but also provide direct data support for storm identification.

[0182] In one fault-tolerant implementation, if a serialized data packet lacks a timestamp, it cannot be included in the frequency statistics. Instead, the data packet can be recorded in the exception queue and treated as participating in the storm count once according to the conservative principle to avoid missed detection.

[0183] If a node's coordinates abnormally exceed the canvas boundary, the system can still use its timestamp for frequency statistics, but will not use it for hotspot area analysis. If a single user generates a large number of duplicate requests due to script operations within a short period of time, the system can add user deduplication or session aggregation logic to prevent single-point noise from being misjudged as a global concurrency storm and to prevent redundant data from a single user's operations from being misjudged as a global concurrency storm.

[0184] If the system has reached its minimum entropy limit... If the concurrency frequency continues to rise, the dynamic frequency adjustment module will no longer lower the threshold, but will instead output a strong warning to the upstream management module to trigger higher-level rate limiting or approval measures.

[0185] It should be added that the aforementioned maintenance of the current value refers to not performing the automatic recovery action within the current judgment period. Therefore, even if multiple consecutive time windows are below the concurrent storm threshold, the system in this embodiment will still maintain the existing entropy value carrying limit until a new scheduling strategy or manual configuration is intervened.

[0186] For example, in the financial risk control rules platform, due to the requirement of new regulatory documents to go online on the same day, multiple business teams simultaneously modified the canvas areas such as the transaction monitoring customer profile whitelist exemption approval write-back;

[0187] The front-end interactive interface continuously reports serialized data packets with timestamps and node coordinates. The concurrent storm monitoring module found that the smooth request frequency exceeded the threshold three times in a row within 30 seconds. The dynamic frequency adjustment module then gradually reduced the entropy carrying limit from 10 to 7.

[0188] During this period, a previously acceptable whitelist bypass change was classified as a risk hedging path by the system due to the dense overlap of other changes in the associated hotspot area; its target connection component was temporarily locked, and the new logic was first run and verified in the sandbox, and the restriction was lifted after the storm ended and the system threshold was confirmed by subsequent scheduling.

[0189] The purpose of this mechanism is to explicitly incorporate the current concurrent disturbance potential of the system into the entropy decision model, so that the entropy carrying limit is no longer a static constant, but can adaptively shrink with the storm intensity, thereby achieving early buffering and dynamic entropy reduction of distributed intention conflict storms.

[0190] The foregoing has provided a detailed description of one embodiment of the present invention, but this description is merely a preferred embodiment and should not be construed as limiting the scope of the invention. All equivalent variations and modifications made within the scope of the claims of this invention should still fall within the patent coverage of this invention.

Claims

1. A visual zero-code development platform building system, deployed on a cloud server, communicating with a front-end visual interface and a business operation server via a network interface, characterized in that, include: The baseline state maintenance module stores the current rendering state of the front-end visualization interface and the corresponding initial abstract syntax tree; The intent parsing module collects concurrent operation data from the front-end visualization interface, uses a preset large language model to perform semantic parsing, identifies the target connection component, and generates an abstract syntax tree update instruction. The topology reconstruction module reorganizes the initial abstract syntax tree according to the abstract syntax tree update instruction, generates the target abstract syntax tree, and extracts its directed acyclic graph dependencies. The coupling quantization module extracts the number of cross-module state-sharing nodes and the depth of the closed-loop structure in the dependency relationship of the directed acyclic graph in order to calculate the visual logical coupling entropy value. The risk decision module compares the visualization logic coupling entropy value with the preset entropy value carrying limit: if it is greater than or equal to the limit, a risk hedging instruction is generated; if it is less than the limit, an just-in-time compilation instruction is generated. The adaptive execution module responds to the risk hedging instruction by generating a visual degradation signal to lock the target connection component and generating a logical isolation signal to inject into the sandbox running node in the business operation server. After verifying that there are no operational abnormalities, the lock is released. In response to the just-in-time compilation instruction, it performs a hot update operation on the underlying code in the business runtime server based on the target abstract syntax tree.

2. The visual zero-code development platform construction system according to claim 1, characterized in that, The intent parsing module includes: The feature extraction unit is used to extract features from the concurrent operation data to obtain the visual drag sequence and component connection relationship; The intent inference unit is used to construct prompt words based on a preset zero-code component business dictionary, and input the visual drag sequence and the component connection relationship into the preset large language model in combination with the prompt words to output business intent text; The instruction synthesis unit is used to convert the business intent text into a structured operation script and parse the structured operation script into the abstract syntax tree update instruction.

3. The visual zero-code development platform construction system according to claim 1, characterized in that, The topology reconstruction module includes: A node injection unit is used to inject temporary state variables and conditional branch nodes into the initial abstract syntax tree according to the abstract syntax tree update instruction, so as to generate the target abstract syntax tree; Dependency traversal unit, used to perform depth-first traversal of the target abstract syntax tree to identify cross-module reference paths; The graph construction unit is used to construct the directed acyclic graph dependency relationship based on the cross-module reference path.

4. The visual zero-code development platform construction system according to claim 1, characterized in that, The coupling quantization module includes: The state complexity calculation unit is used to count the number of cross-module state sharing nodes based on the dependency relationship of the directed acyclic graph, and multiply the number of cross-module state sharing nodes by a preset state weight coefficient to generate the state sharing complexity. A cycle risk calculation unit is used to detect closed-loop structures in the dependencies of the directed acyclic graph and calculate the cycle dependency risk value based on the depth of the closed-loop structure. The entropy fusion unit is used to perform a weighted summation of the state sharing complexity and the circular dependency risk value to output the visual logic coupling entropy value.

5. The visual zero-code development platform construction system according to claim 4, characterized in that, The cycle risk calculation unit is used to detect closed-loop structures in the directed acyclic graph dependencies and calculate the cycle dependency risk value based on the depth of the closed-loop structure. Specifically, it is configured as follows: If the depth of the closed-loop structure is greater than a preset depth threshold, a first risk weight coefficient is assigned to the closed-loop structure, and the depth of the closed-loop structure is multiplied by the first risk weight coefficient to obtain the circular dependency risk value. If the depth of the closed-loop structure is less than or equal to the preset depth threshold, a second risk weight coefficient is assigned to the closed-loop structure, and the depth of the closed-loop structure is multiplied by the second risk weight coefficient to obtain the circular dependency risk value. Wherein, the first risk weight coefficient is greater than the second risk weight coefficient.

6. The visual zero-code development platform construction system according to claim 1, characterized in that, The adaptive execution module generates a visual degradation signal to lock the target connection component of the front-end visualization interface, including: The permission downgrade unit is used to generate the visual downgrade signal based on the risk hedging instruction; The interface reconstruction unit is used to respond to the visual degradation signal and downgrade the target connection component in the front-end visual interface from the advanced dynamic connection mode to the basic unidirectional connection mode. An operation locking unit is used to intercept editing requests for the target connection component after it has been downgraded to the basic unidirectional connection mode, so as to lock the target connection component.

7. The visual zero-code development platform construction system according to claim 1, characterized in that, The adaptive execution module generates logical isolation signals to inject sandboxed runtime nodes into the business operation server, including: A sandbox creation unit is used to allocate independent memory space in the business operation server in response to the logical isolation signal to build an isolation sandbox; A logical migration unit is used to compile the target abstract syntax tree into executable code and migrate the executable code to the isolation sandbox; The status monitoring unit is used to run the executable code within the isolation sandbox and intercept the executable code's write operations to the preset global state machine in the business operation server.

8. The visual zero-code development platform construction system according to claim 1, characterized in that, The hot update operation in the adaptive execution module, which executes the underlying code in the business execution server based on the target abstract syntax tree, includes: An incremental compilation unit is used to compare the target abstract syntax tree with the initial abstract syntax tree in response to the just-in-time compilation instruction to generate incremental bytecode; The memory replacement unit is used to replace the old version bytecode corresponding to the initial abstract syntax tree in the memory of the business running server with the incremental bytecode during system runtime, so as to complete the hot update operation of the underlying code.

9. The visual zero-code development platform construction system according to claim 1, characterized in that, Also includes: The concurrent storm monitoring module is used to collect the frequency of operation requests of the front-end visualization interface within a preset time window; The dynamic frequency adjustment module is used to determine whether the frequency of the operation request is greater than a preset concurrent storm threshold; If the frequency of the operation request exceeds the concurrent storm threshold, a storm warning signal is generated to dynamically reduce the preset entropy carrying limit according to a preset decay step size. If the frequency of the operation request is less than or equal to the concurrent storm threshold, the current value of the preset entropy carrying limit is maintained.

10. The visual zero-code development platform construction system according to claim 1, characterized in that, The front-end visualization interface is a user interaction interface for configuring business rule nodes, and the concurrent operation data is a serialized data packet carrying timestamps and node coordinates.

Images