Intelligent software development auxiliary system and use method

Abstract

The invention provides an intelligent software development auxiliary system and a use method, and belongs to the technical field of computer software development. The system comprises a project demand analysis module which is used for obtaining and analyzing project demand data and generating feature vectors of demands; the code style optimization module is used for analyzing semantics and styles of the original codes, analyzing and normalizing the original code structures, and generating code structures and style specifications meeting project standards; the intelligent code completion module is used for analyzing context semantics of the codes after style optimization, generating code completion suggestions conforming to project standards in combination with project demand data, and outputting structured completion code snippets; the technology stack intelligent recommendation module automatically recommends an optimal technology stack for the project according to the project demand data and the optimized code structure; and the development behavior risk detection module monitors programming behaviors of developers in real time, captures abnormal operations, marks potential risks and generates operation optimization suggestions.

Description

Technical Field

[0001] The present invention relates to the technical field of computer software development, and particularly relates to an intelligent software development assistance system and a usage method thereof. Background Art

[0002] Software development is a complex and time-consuming task. Developers often face high work pressure and tight project deadlines. The development, maintenance, and extension costs of software can be reduced in many aspects by designing a reasonable software architecture and adopting an optimized development process to adapt to the rapid growth of the code volume of software projects. However, it is still difficult to balance quality and development efficiency. On this basis, code completion through an integrated development environment (IDE) also reduces the workload of programmers to a certain extent. However, due to the complexity of the semantics of code files in software projects, the readability and maintainability of code often depend on the personal habits of programmers and team norms, lacking a unified standard. As a result, existing code IDEs are difficult to perform code completion or code generation that conforms to the development team norms based on the understanding of the code, and there are still problems of low development efficiency, especially when facing large and complex code libraries, the above problems are more prominent.

[0003] The existing patent document CN118860380A discloses an intelligent assistance method and system for software development. By obtaining target user requirement data, analyzing the characteristics of front-end and back-end frameworks and interface specifications, ensuring that the selected technology stack is compatible with project requirements, selecting the most suitable framework combination from the framework resource library, reducing manual configuration and selection time, analyzing the interface specifications of front-end and back-end frameworks, matching the interface types of front-end and back-end frameworks, generating an interface configuration document, reducing development and testing problems caused by interface mismatches, analyzing the data flow path and the dependencies between components, adjusting the routing configuration, generating a routing configuration file, optimizing the data flow path, improving system performance and response speed, reducing manual configuration errors, and improving the user experience and interactivity of the system. Although this existing technology can automatically select and recommend suitable frameworks and libraries according to project requirements, there are often significant differences in the personal habits and behavior norms of different developers. As a result, in the face of similar or even the same development requirements, their code styles and structures are very different. Relying solely on the technology stack determined by project requirements may be difficult to be compatible with the uncertain code structure, and the technology selection is out of touch with the actual development process of the project, resulting in refactoring and technical debt problems. Summary of the Invention

[0004] The main purpose of the present invention is to provide an intelligent software development assistance system and a usage method, aiming to solve the problems in the prior art that due to the significant differences in the personal habits and behavior norms of different developers, in the face of similar or even the same development requirements, their code styles and structures are very different. It is difficult for the technology stack determined only by the project requirements to be compatible with the uncertain code structure, and the technology selection is out of touch with the actual development process of the project, resulting in refactoring and technical debt problems. By directly performing code completion on the standardized code structure obtained after optimizing the original code style to ensure that the completed code meets the established style requirements, and performing code error identification and immediate error correction on the basis of the completed code to obtain the optimized code, and introducing the characteristics of the optimized code structure into the recommendation process to make the recommended technology stack more in line with the actual situation of the project.

[0005] An embodiment of the present invention provides an intelligent software development assistance system, including:

[0006] A project requirement analysis module, configured to obtain and analyze project requirement data and generate a feature vector of the requirements;

[0007] A code style optimization module, configured to analyze the semantics and style of the original code, parse and standardize the original code structure, and generate a code structure and style specification that meet the project standards;

[0008] An intelligent code completion module, configured to analyze the context semantics of the code after style optimization, generate code completion suggestions that meet the project standards in combination with the project requirement data, and output structured completed code segments;

[0009] A technology stack intelligent recommendation module, which automatically recommends the best technology stack for the project according to the project requirement data and the optimized code structure;

[0010] A development behavior risk detection module, which monitors the programming behavior of developers in real time, captures abnormal operations and marks potential risks, and generates operation optimization suggestions.

[0011] As a further preferred solution, the intelligent software development assistance system further includes:

[0012] An error detection and optimization module, which adopts a dual detection mechanism, and based on syntax rules and performance optimization requirements, captures syntax, logic, and performance errors in the code in real time, realizes immediate error correction and generates correction suggestions;

[0013] A security test and protection module, which integrates the information of the recommended technology stack, automatically generates test cases adapted to the technology stack, covers critical paths and high-risk operations, and at the same time provides targeted repair solutions through automated vulnerability detection and sensitive information identification.

[0014] As a further preferred solution, the project requirement analysis module includes:

[0015] A requirement text analysis unit that performs word segmentation, part-of-speech tagging on the input requirement document, and extracts key requirement elements, where the key requirement elements include but are not limited to functional requirement elements, performance requirement elements, technical requirement elements, and security requirement elements;

[0016] A feature vector generation unit that converts the extracted key requirement elements into project requirement feature vectors.

[0017] As a further preferred solution, the code style optimization module includes:

[0018] A code semantics analysis unit that analyzes variables, functions, and comments in the original code to generate an original code semantics structure diagram;

[0019] A code style checking unit that detects code style consistency according to project standards;

[0020] A normalized code generation unit that optimizes code specifications using a reinforcement learning algorithm and outputs normalized code that conforms to the project style.

[0021] As a further preferred solution, the intelligent code completion module includes:

[0022] A context semantics analysis unit that analyzes the context of the code after style optimization to capture the semantic structure;

[0023] A requirement combination and completion unit that combines the semantic structure of the current code context with the project requirement feature vectors to generate structured code completion fragments;

[0024] A structured code output unit that seamlessly combines the code completion fragments with the existing code to form the finally output code completion fragments.

[0025] As a further preferred solution, the error detection and optimization module includes:

[0026] An error detection unit that detects syntax and logical errors in the completed code and combines performance analysis to detect performance bottlenecks;

[0027] An immediate error correction unit that provides immediate error correction and optimization suggestions based on the error type and historical data to obtain optimized code.

[0028] As a further preferred solution, the technology stack intelligent recommendation module includes:

[0029] The requirement mapping unit analyzes the optimized code structure using a code analysis tool, extracts key structural elements to form a code structure feature vector. The key structural elements include, but are not limited to, framework dependencies, functional module division, and library usage information. It combines the code structure feature vector with the project requirement feature vector extracted by the feature vector generation unit of the project requirement parsing module to form a multi-dimensional feature vector input;

[0030] The knowledge graph construction unit constructs a technology stack knowledge graph using graph neural network construction technology, and establishes corresponding connections and weights through the mapping relationships between technology stack nodes, code structures, and project requirement features;

[0031] The optimal technology stack recommendation unit combines the project requirement feature vector and the technology stack information in the knowledge graph, uses graph neural network to evaluate the matching degree between the technology stack and the code structure, makes technology stack recommendations based on the collaborative filtering algorithm, and introduces the feedback mechanism of reinforcement learning to dynamically optimize the recommendation results.

[0032] As a further preferred solution, the development behavior risk detection module includes:

[0033] The behavior pattern monitoring unit collects and analyzes the operation behavior patterns of developers, and identifies normal development operations and abnormal operations;

[0034] The anomaly detection unit performs anomaly detection on the programming behavior flow and marks abnormal operations in real time;

[0035] The optimization suggestion generation unit analyzes the detected abnormal operations, determines whether they are risk operations, and gives operation optimization suggestions.

[0036] As a further preferred solution, the security testing and protection module includes:

[0037] The test case generation unit uses a generative adversarial network to generate test cases adapted to the technology stack, covering key paths and high-risk operations in the project;

[0038] The vulnerability detection unit performs semantic analysis on the optimized code and identifies potential security vulnerabilities therein;

[0039] The sensitive information identification unit identifies and marks sensitive information in the optimized code or comments;

[0040] The repair suggestion generation unit generates repair solutions for the detected vulnerabilities and sensitive information.

[0041] On the other hand, the embodiment of the present invention also provides a usage method of an intelligent software development assistance system, including the following steps:

[0042] Step 1: The developer writes the code. The system automatically analyzes the semantics and style of the original code, parses and normalizes the structure of the original code, and outputs the normalized code that conforms to the project style.

[0043] Step 2: Analyze the context semantics of the code after style optimization, capture the semantic structure, combine the semantic structure of the current code context with the project requirement feature vector, generate a structured code completion snippet, and output the code completion snippet that seamlessly integrates with the existing code.

[0044] Step 3: Based on a dual detection mechanism of grammar rules and performance optimization, real-time capture syntax, logic, and performance errors in the completed code. According to the error types and historical data, provide immediate error correction and optimization suggestions to obtain the optimized code.

[0045] Step 4: Automatically recommend the best technology stack for the project according to the project requirement data and the optimized code structure.

[0046] Step 5: Real-time monitor the developer's programming behavior during development, capture abnormal operations and mark potential risks, and generate operation optimization suggestions.

[0047] Step 6: Integrate the recommended technology stack information, automatically generate test cases adapted to the technology stack, cover the critical path and high-risk operations, perform semantic analysis on the optimized code and identify potential security vulnerabilities in it, identify and mark sensitive information in the optimized code or comments, and provide targeted repair solutions.

[0048] As a further preferred solution, in Step 4, according to the project requirement data and the optimized code structure, automatically recommend the best technology stack for the project, specifically including:

[0049] Step 401: Use a code analysis tool to analyze the optimized code structure, extract key structural elements to form a code structure feature vector, and combine it with the project requirement feature vector to form a multi-dimensional feature vector input.

[0050] Step 402: Adopt a graph neural network to construct a technology stack knowledge graph, introduce the optimized code structure as a new feature dimension into the knowledge graph, and construct the mapping relationship between the technology stack nodes, the code structure, and the project requirement features.

[0051] Step 403: Combine the project requirement feature vector and the technology stack information in the knowledge graph, perform technology stack recommendation based on the collaborative filtering algorithm, use the graph neural network to evaluate the matching degree between the technology stack and the code structure, and introduce the feedback mechanism of reinforcement learning to dynamically optimize the recommendation results.

[0052] The present invention provides an intelligent software development assistance system, which achieves the consistency of code format and style for the original code, provides intelligent code completion and generation based on the formatted code, detects and corrects syntax, logic, and performance errors for the completed code, provides high-quality code after optimization for the recommended technology stack, combines the optimized code structure with project requirements, dynamically recommends appropriate technology stacks, monitors developers' behaviors during the development process, identifies risks and provides behavior optimization suggestions, and simultaneously generates automated test cases with the support of the recommended technology stack to detect the security and stability of the code. Through layers of completion, optimization, and detection, the code quality is significantly improved, the development efficiency is enhanced, and the structure of the code after completion and detection conforms to the recommended technology stack through the logical progression relationship between modules, improving the accuracy of the recommendation. At the same time, combined with the monitoring and analysis of development behaviors, it ensures that development behaviors conform to best practices, helps developers improve programming habits, prevents the introduction of potential risks, and reduces risks caused by improper operations.

[0053] Aiming at the problems of mismatch between technology stack recommendation and code structure, and disconnection between technology selection and development process in the prior art, this technical solution can intelligently adjust the recommended results of the technology stack based on project requirements and in combination with the developer's personal coding style and behavior habits through a progressive strategy of code style optimization, code completion, error correction optimization, and intelligent technology stack recommendation. Through in-depth analysis of the code structure and continuous adaptation to project requirements, it ensures that the recommended technology stack is highly compatible with the developer's actual working habits and code style, thus effectively avoiding the generation of refactoring and technical debt, and improving the long-term maintainability of development efficiency and code quality. BRIEF DESCRIPTION OF THE DRAWINGS

[0054] In order to more clearly illustrate the technical solutions of the embodiments of the present application, the following will briefly introduce the drawings required for the description of the embodiments. Obviously, the following drawings are some embodiments of the present application. For those of ordinary skill in the art, other drawings can be obtained based on these drawings without creative efforts.

[0055] Figure 1 It is a schematic structural diagram of the intelligent software development assistance system provided by the embodiment of the present invention;

[0056] Figure 2 It is a schematic flow diagram of the usage method of the intelligent software development assistance system provided by the embodiment of the present invention. DETAILED DESCRIPTION OF THE EMBODIMENTS

[0057] The following will clearly and completely describe the technical solutions in the embodiments of the present invention with reference to the accompanying drawings in the embodiments of the present invention. Obviously, the described embodiments are some, but not all, embodiments of the present invention. All other embodiments obtained by those of ordinary skill in the art based on the embodiments of the present invention without creative efforts shall fall within the protection scope of the present invention.

[0058] The flowcharts shown in the accompanying drawings are only illustrative examples, and do not necessarily include all the content and operations / steps, nor do they necessarily need to be executed in the described order. For example, some operations / steps can also be decomposed, combined or partially merged, so the actual execution order may change according to the actual situation.

[0059] It should be understood that the terms used in the specification of the present invention are only for the purpose of describing specific embodiments and are not intended to limit the present invention. As used in the specification of the present invention and the appended claims, unless the context clearly indicates otherwise, the singular forms "a", "an" and "the" are intended to include the plural forms.

[0060] Software development is a complex and time-consuming task. Developers often face high-intensity work pressure and tight project deadlines. The development, maintenance and extension costs of software can be reduced in many aspects by designing a reasonable software architecture and adopting an optimized development process, etc., to adapt to the characteristics of the rapid growth of the code volume of software projects. However, it is still difficult to balance quality and development efficiency. On this basis, code completion through an integrated development environment (IDE) also reduces the workload of programmers to a certain extent. However, due to the complexity of the semantics of code files in software projects, the readability and maintainability of code often depend on the personal habits of programmers and team norms, and there is a lack of unified standards, making it difficult for existing code IDEs to perform code completion or code generation that conforms to the development team norms based on the understanding of the code, and there are still problems of low development efficiency. Especially when facing large and complex code libraries, the above problems are more prominent.

[0061] Through intelligent assistance methods and systems, functions such as automatic code generation, automatic debugging, and intelligent suggestions can be provided to reduce the workload of developers, improve work efficiency, and enable them to focus on higher-level design and innovation work.

[0062] Embodiments of the present invention provide an intelligent software development assistance system, which can be applied to computer and server electronic terminal devices. Some embodiments of the present invention will be described in detail with reference to the accompanying drawings. Without conflict, the following embodiments and the features in the embodiments can be combined with each other.

[0063] Please refer to Figure 1 , for a comprehensive description of the intelligent software development assistance system.Figure 1 An intelligent software development assistance system provided by an embodiment of the present invention includes a project requirement analysis module 100, a code style optimization module 200, an intelligent code completion module 300, a technology stack intelligent recommendation module 400, and a development behavior risk detection module 500. Among them, the project requirement analysis module 100 is used to obtain and analyze project requirement data and generate a feature vector of the requirement; the code style optimization module 200 is used to analyze the semantics and style of the original code, parse and normalize the original code structure, and generate a code structure and style specification that meets the project standards; the intelligent code completion module 300 is used to analyze the context semantics of the code after style optimization, generate code completion suggestions that meet the project standards in combination with the project requirement data, and output a structured completed code segment; the technology stack intelligent recommendation module 400 automatically recommends the best technology stack for the project according to the project requirement data and the optimized code structure; the development behavior risk detection module 500 monitors the programming behavior of the developer in real time, captures abnormal operations and marks potential risks, and generates operation optimization suggestions.

[0064] In this embodiment, the intelligent software development assistance system includes multiple modules, aiming to optimize the software development process through collaborative work, improve development efficiency and code quality, and reduce development risks at the same time. Among them, the core function of the project requirement analysis module 100 is to obtain and analyze project requirement data and generate feature vectors of the requirements. Specifically, this module extracts key requirement elements such as functions, performance, and security by analyzing project requirement documents, and uses natural language processing technology for text analysis. The generated feature vectors can not only express the specific content of the requirements, help understand the core requirements of the project, but also provide key inputs on the project background and objectives for subsequent modules and provide precise guidance. The code style optimization module 200 analyzes the original code, parses the syntax, style, and structure of the code, and automatically implements normalization processing. For example, it can adjust the code according to project standards (such as naming rules, comment styles, indentation specifications, etc.) to make it meet project requirements and output a code structure that meets the specifications, reducing the later maintenance cost caused by inconsistent code styles. After the code style is optimized, the intelligent code completion module 300 analyzes the context semantics of the optimized code, and combines with the project requirement feature vectors generated by the project requirement analysis module 100 to intelligently generate code snippet completions that meet project requirements. The technology stack intelligent recommendation module 400 combines the project requirement data with the characteristics of the optimized code structure, models the association between the technology stack and project requirements and code structure, and intelligently generates a list of technology stacks suitable for the current project, and the list is sorted according to the degree of adaptation. The development behavior risk detection module 500 monitors developers' programming behaviors in real time, uses behavior analysis algorithms to identify normal operations and potential abnormal behaviors, can detect common programming errors and non-standard operations, and can also identify high-risk operations that may lead to vulnerabilities, such as insecure function calls or non-standard dependency usage. When an abnormal behavior is detected, the system will mark it in real time and generate optimization suggestions to help developers correct improper operations in time, thereby reducing potential risks in development.

[0065] In some embodiments, the intelligent software development assistance system further includes an error detection and optimization module 600. The error detection and optimization module 600 adopts a dual detection mechanism, and based on syntax rules and performance optimization requirements, it captures syntax, logic, and performance errors in the code in real time, realizes instant error correction and generates correction suggestions.

[0066] In this embodiment, the error detection and optimization module 600 is called to work between the intelligent code completion module 300 and the technology stack intelligent recommendation module 400. The processing object of the error detection and optimization module 600 is the completed code. Based on a dual detection mechanism of syntax rules and performance optimization, it real-time captures syntax, logic, and performance errors in the completed code, and provides instant error correction and optimization suggestions according to the error types and historical data, obtains the optimized code, and passes the optimized code to the subsequent technology stack intelligent recommendation module 400 to cooperate with the project requirement data for intelligent recommendation of the technology stack.

[0067] In some embodiments, the intelligent software development assistance system further includes a full test and protection module 700. The security test and protection module 700 integrates the recommended technology stack information, automatically generates test cases adapted to the technology stack, covers critical paths and high-risk operations, and at the same time provides targeted repair solutions through automated vulnerability detection and sensitive information identification.

[0068] In this embodiment, the security test and protection module 700 is responsible for comprehensively testing the security and stability of the code. With the support of the technology stack recommended by the technology stack intelligent recommendation module 400, it generates automated test cases and conducts coverage regression testing to ensure the code security and reliable performance of the main functional paths, automatically identifies potential security vulnerabilities and sensitive information, generates repair solutions, and prevents function degradation or performance decline in the subsequent development process. And it can output a detailed security and stability test report, including the results of code function testing, vulnerability detection, and performance testing, providing security guarantees for system online and continuous optimization.

[0069] Specifically, the intelligent software development assistance system realizes the consistency of the code format and style for the original code, provides intelligent code completion and generation on the basis of the formatted code, detects and corrects syntax, logic, and performance errors for the completed code, provides optimized high-quality code for the recommended technology stack, combines the optimized code structure with project requirements, dynamically recommends appropriate technology stacks, monitors developers' behaviors during development, identifies risks and provides behavior optimization suggestions, and at the same time generates automated test cases with the support of the recommended technology stack to detect the security and stability of the code. After layers of completion, optimization, and detection, the code quality is greatly improved, the development efficiency is enhanced, and the structure of the code after completion and detection conforms to the recommended technology stack through the logical progressive relationship between modules, improving the accuracy of the recommendation. At the same time, combined with the monitoring and analysis of development behaviors, it ensures that development behaviors conform to best practices, helps developers improve programming habits, prevents the introduction of potential risks, and reduces risks caused by improper operations.

[0070] In some embodiments, the project requirement parsing module 100 includes a requirement text parsing unit 101 and a feature vector generation unit 102. Among them, the requirement text parsing unit 101 performs word segmentation, part-of-speech tagging on the input requirement document, and extracts key requirement elements. The key requirement elements include requirement elements in aspects such as functional requirements, performance requirements, technical requirements, and security requirements; the feature vector generation unit 102 converts the extracted key requirement elements into project requirement feature vectors.

[0071] In this embodiment, the requirement text parsing unit 101 uses the BERT model in natural language processing (NLP) technology to preprocess the requirement document. BERT is a bidirectional language model based on Transformer. Taking the project requirement document as the model input, the BERT model can capture the context information in the requirement document, perform word segmentation on the text, generate context word vectors for each word, perform NER processing on the text, identify key requirement elements, and output structured requirement elements, including labels for each key requirement item. For example, the functional requirement of a certain development project is high concurrency, and the performance requirement is to support concurrent users. The feature vector generation unit 102 processes the word vector sequence extracted by the BERT model through a long short-term memory network (LSTM) model. The LSTM performs temporal modeling on these word vectors, captures the dependency relationship between words, extracts high-level features of the requirements, and converts them into fixed-length feature vectors. The hidden layer state at the last moment output by the LSTM is used as the feature vector of the project requirement. Exemplarily, the aforementioned certain project requirement document includes "need to support high-concurrency user access". This unit will mark and extract key elements such as "high concurrency" and "user access" through NLP technology, and generate project requirement feature vectors, which are input into subsequent modules for further processing.

[0072] Specifically, through the parsing and feature extraction of project requirements by the project requirement parsing module 100, accurate requirement data can be provided for subsequent code optimization and technology stack recommendation, enabling the system to be more in line with actual requirements when processing code. The effectiveness of this module significantly improves the system's adaptability to project requirements, ensuring that the developed code structure and style can better meet business requirements.

[0073] In some embodiments, the code style optimization module 200 includes a code semantic parsing unit 201, a code style checking unit 202, and a normalized code generation unit 203. Among them, the code semantic parsing unit 201 parses variables, functions, and comments in the original code to generate an original code semantic structure diagram; the code style checking unit 202 detects the consistency of code style according to project standards; the normalized code generation unit 203 uses a reinforcement learning algorithm to optimize code specifications and outputs normalized code that conforms to the project style.

[0074] In this embodiment, the code semantic parsing unit 201 uses a combined model of abstract syntax tree (AST) and deep learning for code semantic parsing. Among them, the AST converts the input original code into a structured tree structure for analyzing variables, functions, and comments in the original code. The deep learning model, such as the graph neural network (GNN), performs semantic modeling on the nodes representing various elements of the code in the AST, such as variables, functions, and expressions, and captures the complex structure of the code through information propagation between nodes, generating and outputting a semantic structure diagram of the code. The semantic structure diagram of the code includes the relationships of variables, function calls, and comments. The semantic structure diagram output by the code semantic parsing unit 201 is passed to the code style checking unit 202, and the code style checking unit 202 analyzes the consistency of the code style based on a combined model of a rule engine and deep learning, including naming specifications, indentation specifications, etc. The deep learning model, such as the convolutional neural network (CNN), extracts local features of the code through convolutional operations, combines with the rule engine and style rules for comparison to check the consistency of the code style, and outputs a style consistency score and an error report to characterize the style problems of the code. The normalized code generation unit 203 uses a reinforcement learning (RL) model to learn the code style optimization strategy, adjusts the code structure through a reward mechanism in multiple rounds of trials to make it meet the style requirement standards of the project, and outputs the normalized code. Reinforcement learning, such as the deep Q-learning network (DQN), has the following model architecture:

[0075] State (S): Represents the current style and structure of the code, such as whether the variable naming is standardized, whether the function conforms to the indentation specification, etc.

[0076] Action (A): Represents the code modification or adjustment operation, such as renaming variables, modifying function signatures, modifying function structures, modifying indentation or comment formats, etc. Among them, each action has clear modification rules. For example, when renaming a variable, the DQN can use the set naming specification to generate a new name.

[0077] Reward (R): Evaluates whether the style and specification of the code after modification meet the requirements of the project, and gives a reward according to the matching degree of the code style and specification. The reward function is designed as follows:

[0078] R(S t ,A t ) = ω1 * Consistency(S t ) + ω2 * Correctness(S t ) + ω2 * Efficiency

[0079] (S t ),

[0080] where Consistency(S t) Represents the consistency score indicating whether the code conforms to unified style specifications such as naming, indentation, and comments; Correctness(S t ) Represents the correctness score of the code logic. For example, whether variables meet functional requirements, whether functions work as expected, etc.; Efficiency(S t ) Represents the efficiency score indicating whether the code meets performance requirements. For example, whether there are redundant operations in functions; ω1, ω2, ω2 are the weights of each scoring metric.

[0081] DQN learns the optimal policy by optimizing the Q-value function, uses a deep neural network to approximate the Q-value function, and the Q-value represents the maximum cumulative reward that can be obtained by performing a certain action in a given state. During training, DQN adopts an ε-greedy strategy to balance exploration and exploitation, that is, selects a random action to explore more possible code modification methods, and selects the action with the highest Q-value to exploit the learned optimal policy. By continuously interacting with the environment (i.e., the code normalization task), it optimizes its Q-value function and finally learns the best code normalization policy.

[0082] Exemplarily, if there are problems with non-standard variable naming and inconsistent indentation in the original code, the code style checking unit 202 will detect and mark the problem, and the normalized code generation unit 203 uses the reinforcement learning model to automatically adjust the variable naming style and indentation according to the project specifications. As shown in Table 1 below, after training with the DQN model, the model learns the following modifications: (1) Rename variables: Rename x and y to num1 and num2 to make the variable names more descriptive; (2) Adjust indentation: Fix inconsistent indentation to make the code conform to the specifications.

[0083] Table 1 Comparison of code before and after code style optimization

[0084]

[0085] Specifically, the code style optimization module 200 combines project standards to automatically normalize the original code. Through semantic analysis and style checking of the original code, it automatically generates normalized code that meets project standards, improves the structure and readability of the code, reduces the workload of manual modification, and improves the consistency and maintainability of the code. By introducing a reinforcement learning algorithm, it optimizes the accuracy of code specification generation, making the code style gradually fit the programming habits of the team and project requirements, thereby improving the maintainability and scalability of the code and achieving efficient maintenance of large-scale project code libraries.

[0086] In some embodiments, the intelligent code completion module 300 includes a context semantic analysis unit 301, a requirement combination completion unit 302, and a structured code output unit 303. Among them, the context semantic analysis unit 301 analyzes the code context after style optimization to capture the semantic structure; the requirement combination completion unit 302 combines the semantic structure of the current code context with the project requirement feature vector to generate a structured code completion snippet; the structured code output unit 303 seamlessly combines the completion code snippet with the existing code to form the finally output completion code snippet.

[0087] In this embodiment, the context semantic analysis unit 301 can use a Transformer model to analyze the code context and capture the semantic and context relationships of variables and functions in the code. For example, use the GPT-3 model to perform context analysis on the input code snippet after style optimization, and generate and output a context semantic representation based on its understanding of similar codes in its training corpus, which contains the structure and logical information of the current code. The requirement combination completion unit 302 uses a multi-modal neural network to combine the project requirement feature vector and the code context semantics, fuse the code context semantics with the project requirement feature vector, and generate a completion code snippet that meets the requirements. The most suitable completion snippet can be selected by calculating the similarity between the context semantics and the requirement vector. Input the completion code snippet and the code after style optimization into the structured code output unit 303, and use a graph neural network (GNN) to fuse the completion code snippet and the existing code according to the graph representation of the code structure to ensure seamless docking of the completion code with the structure of the existing code, and output the finally completed and fused code snippet.

[0088] Exemplarily, when a developer writes a certain function, the intelligent code completion module 300 suggests appropriate code completion according to the context semantics and project requirement features, such as providing an appropriate function body or parameter settings.

[0089] Specifically, by analyzing the code context after style optimization, the intelligent code completion module 300 can identify the logical context of the current code, and combine the project requirement data to provide intelligent code completion suggestions for developers, ensuring that the generated code snippet can be seamlessly integrated into the existing code, making the completed code meet both the syntax requirements and the functional requirements, further improving the development efficiency and code quality, avoiding common programming errors, and ensuring that the completed code highly matches the project requirements and style.

[0090] In some embodiments, after code completion, error detection and optimization work processes are carried out, and only the optimized code is passed to the subsequent technology stack intelligent recommendation module 400 for intelligent recommendation of the technology stack. The error detection and optimization module 600 is called to work between the intelligent code completion module 300 and the technology stack intelligent recommendation module 400, and the processing object of the error detection and optimization module 600 is the completed code. The error detection and optimization module 600 includes an error detection unit 601 and an immediate error correction unit 602. Among them, the error detection unit 601 is used to detect syntax and logical errors in the completed code, and detect performance bottlenecks in combination with performance analysis. The immediate error correction unit 602 provides immediate error correction and optimization suggestions according to the error type and historical data, and obtains the optimized code.

[0091] In this embodiment, the error detection unit 601 performs syntax detection, logical error detection, and performance detection on the completed code respectively. Among them, syntax detection is to check whether the completed code conforms to the syntax rules, and logical error detection is to use static analysis tools (such as SonarQube, Pylint, Checkstyle) to identify potential logical errors in the completed code, such as unused variables, potential null pointer references, dead code, etc. Performance detection is to use performance analysis tools (such as Py-Spy, cProfile, gprof, etc.) to analyze potential bottlenecks in the completed code, such as inefficient loops, slow function calls, redundant calculations, etc. The immediate error correction unit 602 is responsible for providing immediate error correction and optimization suggestions according to the error type and historical data, which can be implemented by using a repair rule engine, supervised learning, or reinforcement learning. For example, a rule-based engine is used to repair according to historical data and common programming specifications. The rule engine will provide corresponding repair suggestions through a rule library according to the error types existing in the code (such as syntax errors, logical errors, performance bottlenecks, etc.). Or through machine learning algorithms such as decision trees and neural networks, the most appropriate repair suggestions are automatically provided according to the error type and historical code repair data.

[0092] Exemplarily, when the error detection unit 601 detects a possible performance bottleneck using a performance analysis tool, the immediate error correction unit 602 can infer an optimization strategy through historical data, that is, to optimize the code by changing it to use the built-in sum function as shown in Table 2 below.

[0093] Table 2 Comparison of code before and after error detection and optimization

[0094]

[0095] Specifically, the error detection and optimization module 600 uses a dual-detection mechanism, combines syntax and performance optimization rules, and detects and fixes syntax, logic, and performance errors in the code in real time to ensure the stability and efficiency of the code quality. The instant error correction function greatly improves the efficiency of code repair and reduces the later maintenance cost.

[0096] In some embodiments, the technology stack intelligent recommendation module 400 includes a requirement mapping unit 401, a knowledge graph construction unit 402, and an optimal technology stack recommendation unit 403. Among them, the requirement mapping unit 401 analyzes the optimized code structure using a code analysis tool, extracts key structural elements to form a code structure feature vector. The key structural elements include, but are not limited to, framework dependencies, functional module division, and library usage information. The code structure feature vector is combined with the project requirement feature vector extracted by the feature vector generation unit of the project requirement parsing module to form a multi-dimensional feature vector input. The knowledge graph construction unit 402 constructs a technology stack knowledge graph using a graph neural network, and establishes corresponding connections and weights through the mapping relationship between technology stack nodes and code structures and project requirement features. The optimal technology stack recommendation unit 403 combines the project requirement feature vector and the technology stack information of the knowledge graph, uses a graph neural network to evaluate the matching degree between the technology stack and the code structure, recommends the technology stack based on the collaborative filtering algorithm, and introduces a feedback mechanism of reinforcement learning to dynamically optimize the recommendation result.

[0097] In this embodiment, the requirement mapping unit 401 uses a feature matching algorithm combined with embedded learning (such as Word2Vec, FastText) to compare the code structure feature vector and the project requirement feature vector, calculate the similarity between the two, and form a multi-dimensional feature vector for technology stack recommendation. The knowledge graph construction unit 402 uses a graph neural network (GNN) to construct a technology stack knowledge graph, that is, maps the technology stack information into graph nodes. The technology stack information includes components such as tools, libraries, and frameworks of the technology stack. Each of the above technology stack components is regarded as a node in the graph, and the dependencies, functional compatibility, collaborative work, etc. between them are represented by the edges between the nodes, and the code structure, project requirement features, and technology stack features are associated. By learning the relationships and similarities between the nodes through the GNN algorithm, the technology stack knowledge graph is output. Among them, for the association between the code structure and the technology stack features, functional modules such as data processing, machine learning, and network requests in the code structure can be matched with the corresponding technology stack components. By extracting features from the modules in the code, embedding vectors of code segments can be generated through models such as BERT or Doc2Vec, and these embedding vectors of the code segments are matched with the embedding vectors of the technology stack components to form the association of nodes. For example, if there are a large number of matrix operations in the code, the system will associate it with libraries such as NumPy or TensorFlow. If the code involves web development, it will be associated with frameworks such as Django or Flask. For the association between the project requirement features and the technology stack features, project requirement features such as performance requirements, scalability requirements, and security requirements will affect the selection of the technology stack. By analyzing the requirement features, these requirements are matched with the features of the technology stack components. For example, if the project requirements require processing a large amount of data, the system will recommend technology stack components designed for efficient data processing (such as Apache Spark, Dask, etc.).

[0098] The goal of the optimal technology stack recommendation unit 403 is to recommend the optimal technology stack components for developers based on the project requirements, code structure, and historical usage data, and adapt to project changes through dynamic optimization. Taking the project requirement feature vector, technology stack knowledge graph, and optimized code structure as inputs, first, the matching degree between the code structure and the technology stack is evaluated based on the graph neural network (GNN). Second, the collaborative filtering algorithm is combined for technology stack recommendation, and a set of recommended technology stacks is output. Finally, through the feedback mechanism of reinforcement learning, the recommendation results are dynamically optimized to improve the accuracy and adaptability of the recommendation. Among them, the matching between the code structure and the technology stack is a key link in the optimal technology stack recommendation unit 403. Taking each technology stack component and code function module as nodes in the graph, the graph neural network is used to transmit information. Through the multi-layer message passing mechanism, the graph neural network updates the feature representation of the nodes, and finally calculates the matching degree between the code function module and the technology stack component. This process is carried out through the following formula:

[0099] h v (l+1) = Update(h v (l) , Agg({h u (l) : u ∈ N(v)})),

[0100] where h v (l) represents the feature vector of node v at the l-th layer, N(v) is the set of neighbor nodes of node v, Agg is the aggregation operation, and Update is the update operation. Through such calculations, the evaluation result of the matching degree between the code structure and the technology stack component can be obtained.

[0101] Combining the technology stack information of the project requirement feature vector and the knowledge graph, technology stack recommendation is carried out based on the collaborative filtering algorithm. The historical data training set used records the technology stack components used in different projects and their performance (such as accuracy, runtime, compatibility, etc.). Methods such as cosine similarity and Pearson correlation coefficient are used to calculate the similarity between projects and between technology stack components. Through this similarity, the technology stack components used in similar projects are recommended, so as to recommend technology stack components for the current project.

[0102] Reinforcement learning is introduced to optimize the process of technology stack recommendation. The aim is to dynamically adjust the recommendation strategy so that the recommendation results can better adapt to the changes of the project and improve the recommendation quality. The states in reinforcement learning include information such as project requirement characteristics, the current technology stack, and the development progress of the project. The state can be represented by a state vector, which includes functional requirements, performance requirements, etc. of the project. The action is the technology stack component to be recommended. Each time a recommendation action is taken, one or more technology stack components are selected for recommendation. The performance metric of the recommendation result is used as the reward, such as whether the recommended technology stack fits the project requirements, whether it improves the development efficiency, whether it reduces bugs, etc. The design of the reward function needs to be defined according to the feedback in actual applications, such as:

[0103] R t = f(performance(action t ), developer feedback, adaptation to project needs),

[0104] where R t is the reward at the current moment, f is a function that calculates the performance of the recommended technology stack, considering the project requirement matching degree, developer feedback, and the degree of adaptation to project needs.

[0105] Use Q-learning or Deep Q-Network (DQN) to train the reinforcement learning agent so that it can adjust the recommendation strategy in repeated trials and gradually improve the accuracy of technology stack recommendation.

[0106] After the matching degree evaluation of the above graph neural network, the recommendation of collaborative filtering, and the dynamic optimization of reinforcement learning, the best technology stack recommendation unit 403 finally outputs a technology stack recommendation list. The recommended technology stack not only meets the project requirements but also can be adjusted in real time according to historical data and developer feedback.

[0107] Exemplarily, for the optimized code structure in Table 2, assuming that the project requirements need efficient numerical calculation, the technology stack recommendation module 400 may recommend using the NumPy library to further optimize the performance.

[0108] Specifically, the technology stack intelligent recommendation module 400 combines the project requirement characteristics with the optimized code structure, and through the matching degree evaluation of the code structure and the technology stack by the graph neural network, the technology stack recommendation algorithm of collaborative filtering, and the dynamic optimization mechanism of reinforcement learning, automatically recommends the best technology stack for the project. Through the combination of such multiple mechanisms, the system can not only provide accurate recommendations according to project requirements and historical data, ensure the rationality and adaptability of the technical architecture, make the selected technology stack more compatible with the overall architecture of the project, but also optimize the recommendation results through continuous feedback to ensure that the recommendation system continuously improves the recommendation quality as the project develops.

[0109] In some embodiments, the development behavior risk detection module 500 includes a behavior pattern monitoring unit 501, an anomaly detection unit 502, and an optimization suggestion generation unit 503. Among them, the behavior pattern monitoring unit 501 collects and analyzes the operation behavior patterns of developers, and identifies normal development operations and abnormal operations; the anomaly detection unit 502 performs anomaly detection on the programming behavior flow and marks abnormal operations in real time; the optimization suggestion generation unit 503 analyzes the detected abnormal operations, determines whether they are risk operations, and gives operation optimization suggestions.

[0110] In this embodiment, the behavior pattern monitoring unit 501 monitors and analyzes the programming behaviors of developers based on their operation records (such as editing, submitting code, executing commands, etc.) using anomaly detection algorithms (such as IsolationForest or Autoencoder) to identify whether there are potential abnormal or risk operations. The anomaly detection unit 502 outputs an analysis report on the behavior patterns of developers based on the anomaly detection results of the programming behavior flow, marking abnormal behaviors and risk levels. The optimization suggestion generation unit 503 determines whether it is a risk operation based on the risk level of the detected abnormal operation. If so, it gives corresponding operation optimization suggestions based on the specific behaviors and risk levels of the abnormal operations.

[0111] Exemplarily, if a developer frequently performs non-compliant operations when submitting code, the behavior pattern monitoring unit 501 will detect this behavior, the anomaly detection unit 502 will mark it as an abnormal behavior and a potential risk, and the optimization suggestion generation unit 503 will prompt the developer to improve their operation habits and avoid errors.

[0112] Specifically, the development behavior risk detection module 500 monitors the programming behaviors of developers in real time, can quickly capture abnormal operations and generate optimization suggestions, effectively reducing human errors and potential risk operations. While ensuring the code quality, this module also improves the transparency and security of the development process.

[0113] In some embodiments, the security testing and protection module 700 includes a test case generation unit 701, a vulnerability detection unit 702, a sensitive information identification unit 703, and a repair suggestion generation unit 704. Among them, the test case generation unit 701 uses a generative adversarial network to generate test cases adapted to the technology stack, covering key paths and high-risk operations in the project; the vulnerability detection unit 702 performs semantic analysis on the optimized code and identifies potential security vulnerabilities therein; the sensitive information identification unit 703 identifies and marks sensitive information in the optimized code or comments; the repair suggestion generation unit 704 generates repair solutions for the detected vulnerabilities and sensitive information.

[0114] In this embodiment, the security testing and protection module 700 is responsible for comprehensively testing the security and stability of the code. With the support of the technology stack intelligent recommendation module 400 in recommending the technology stack, the test case generation unit 701 generates automated test cases and conducts coverage regression testing to ensure the code security and reliable performance of the main functional paths. The vulnerability detection unit 702 and the sensitive information identification unit 703 automatically identify potential security vulnerabilities and sensitive information, and the repair suggestion generation unit 704 generates repair solutions to prevent function degradation or performance decline during subsequent development. It can also output detailed security and stability test reports, including the results of code function testing, vulnerability detection, and performance testing, providing security guarantees for system online and continuous optimization.

[0115] Specifically, the security testing and protection module 700 enhances the code security by automatically generating test cases and conducting vulnerability detection and sensitive information identification. It can quickly locate and fix security vulnerabilities, providing a comprehensive security protection layer for the development team and reducing potential security risks.

[0116] Please refer to Figure 2 , Figure 2 which is a schematic flowchart of the usage method of an intelligent software development assistance system provided by an embodiment of this application. The usage method of the intelligent software development assistance system includes the following steps:

[0117] Step 1: The developer writes the code, and the system automatically analyzes the semantics and style of the original code, parses and normalizes the original code structure, and outputs the normalized code that conforms to the project style;

[0118] Step 2: Analyze the context semantics of the code after style optimization, capture the semantic structure, combine the semantic structure of the current code context with the project requirement feature vector, generate structured code completion fragments, and output the code completion fragments that are seamlessly integrated with the existing code;

[0119] Step 3: Based on the dual detection mechanism of syntax rules and performance optimization, capture syntax, logic, and performance errors in the completed code in real time, and provide instant error correction and optimization suggestions according to the error types and historical data to obtain the optimized code;

[0120] Step 4: Automatically recommend the best technology stack for the project according to the project requirement data and the optimized code structure;

[0121] Step 5: Monitor the developer's programming behavior in real time during development, capture abnormal operations and mark potential risks, and generate operation optimization suggestions;

[0122] Step 6: Integrate the recommended technology stack information, automatically generate test cases adapted to the technology stack, covering critical paths and high-risk operations, perform semantic analysis on the optimized code to identify potential security vulnerabilities therein, identify and mark sensitive information in the optimized code or comments, and provide targeted repair solutions.

[0123] In some embodiments, in Step 4, based on the project requirement data and the optimized code structure, the best technology stack is automatically recommended for the project, specifically including:

[0124] Step 401: Use a code analysis tool to analyze the optimized code structure, extract key structural elements to form a code structure feature vector, and combine it with the project requirement feature vector to form a multi-dimensional feature vector input.

[0125] Step 402: Adopt a graph neural network to construct a technology stack knowledge graph, introduce the optimized code structure as a new feature dimension into the knowledge graph, and construct the mapping relationship between technology stack nodes, code structure, and project requirement features.

[0126] Step 403: Combine the project requirement feature vector and the technology stack information in the knowledge graph, use the graph neural network to evaluate the matching degree between the technology stack and the code structure, perform technology stack recommendation based on the collaborative filtering algorithm, and introduce the feedback mechanism of reinforcement learning to dynamically optimize the recommendation result.

[0127] This embodiment is based on the usage process of the intelligent software development assistance system, which solves the disconnection problem between technology stack recommendation and code structure adaptation in the prior art. After the developer writes the code and optimizes the style, the system can not only automatically complete the code, capture syntax, logic, and performance errors in real time through a dual detection mechanism, provide instant error correction and optimization suggestions for the developer, but also construct a technology stack knowledge graph through a graph neural network. The system can accurately recommend the best technology stack according to the optimized code structure and project requirements, further improving the code quality and development efficiency. At the same time, the dynamic feedback mechanism of reinforcement learning is introduced to continuously optimize the technology stack recommendation to ensure its high compatibility with the developer's coding habits and actual project requirements, effectively reducing the need for technical debt and refactoring. In addition, the system also integrates security testing and protection functions to comprehensively improve the security and reliability during the development process.

[0128] It should be noted that those skilled in the art can clearly understand that for the convenience and simplicity of description, the specific process of the usage method of the intelligent software development assistance system described above can refer to the corresponding process in the foregoing embodiment of the intelligent software development assistance system, and will not be elaborated herein.

[0129] It should be understood that the term "and / or" used in the specification and appended claims of the present invention refers to any combination and all possible combinations of one or more of the associated listed items, and includes these combinations. It should be noted that, in this text, the term "comprises", "comprising" or any other variation thereof is intended to cover non-exclusive inclusion, such that a process, method, article or system comprising a series of elements not only includes those elements but also includes other elements not expressly listed, or further includes elements inherent to such process, method, article or system. Without further limitation, an element defined by the statement "comprising an..." does not exclude the presence of additional identical elements in the process, method, article or system comprising the element.

[0130] The serial numbers of the above embodiments of the present invention are only for description and do not represent the superiority or inferiority of the embodiments. The above are only specific embodiments of the present invention, but the protection scope of the present invention is not limited thereto. Any person skilled in the art within the technical scope disclosed by the present invention can easily think of various equivalent modifications or substitutions, and these modifications or substitutions should be covered within the protection scope of the present invention. Therefore, the protection scope of the present invention shall be subject to the protection scope of the claims.

Claims

1. An intelligent software development assistance system, characterized in that: The system comprises: Project requirement parsing module, used to obtain and parse project requirement data and generate feature vectors of requirements; The code style optimization module is used to analyze the semantics and style of the original code, parse and normalize the original code structure, and generate code structure and style specifications that meet project standards; Intelligent code completion module, which is used to analyze the contextual semantics of the style-optimized code, generate code completion suggestions that meet project standards based on project requirement data, and output structured completion code snippets; The technology stack intelligent recommendation module automatically recommends the best technology stack for the project based on project demand data and optimized code structure; Develop a behavioral risk detection module to monitor developers' programming behavior in real time, capture abnormal operations and mark potential risks, and generate operation optimization suggestions.

2. The intelligent software development assistance system according to claim 1, characterized in that: Also includes: The error detection and optimization module adopts a dual detection mechanism to capture syntax, logic and performance errors in the code in real time based on syntax rules and performance optimization requirements, realize instant error correction and generate correction suggestions.

3. The intelligent software development assistance system according to claim 1 or 2, characterized in that: Also includes: The security testing and protection module integrates recommended technology stack information, automatically generates test cases that adapt to the technology stack, covers critical paths and high-risk operations, and provides targeted repair solutions through automated vulnerability detection and sensitive information identification.

4. The intelligent software development assistance system according to claim 1, characterized in that: The project requirements parsing module includes: The requirement text parsing unit performs word segmentation and part-of-speech tagging on the input requirement document and extracts key requirement elements, including but not limited to functional requirement elements, performance requirement elements, technical requirement elements, and security requirement elements; The feature vector generation unit converts the extracted key requirement elements into a project requirement feature vector.

5. The intelligent software development assistance system according to claim 1, characterized in that: The code style optimization module includes: The code semantic analysis unit analyzes the variables, functions, and comments in the original code to generate the original code semantic structure diagram; The code style checking unit detects the consistency of code style according to project standards; The standardized code generation unit uses reinforcement learning algorithms to optimize code specifications and output standardized code that conforms to the project style.

6. The intelligent software development assistance system according to claim 1, characterized in that: The intelligent code completion module includes: Contextual semantic analysis unit, which analyzes the code context after style optimization and captures the semantic structure; The requirement-combined completion unit combines the semantic structure of the current code context with the project requirement feature vector to generate a structured completion code snippet; The structured code output unit seamlessly combines the completed code snippet with the existing code to form the final output completed code snippet.

7. The intelligent software development assistance system according to claim 2, characterized in that: The error detection optimization module comprises: Error detection unit, which detects syntax and logic errors in the completed code and detects performance bottlenecks in combination with performance analysis; The real-time error correction unit provides real-time error correction and optimization suggestions based on error types and historical data to obtain optimized code.

8. The intelligent software development assistance system according to claim 4, characterized in that: The technology stack intelligent recommendation module includes: The requirement mapping unit uses a code analysis tool to analyze the optimized code structure, extract key structural elements to form a code structure feature vector, the key structural elements include but are not limited to framework dependency, functional module division, library usage information, and combine the code structure feature vector with the project requirement feature vector extracted by the feature vector generation unit of the project requirement parsing module to form a multi-dimensional feature vector input; The knowledge graph construction unit uses graph neural networks to build a technology stack knowledge graph, and establishes corresponding connections and weights through the mapping relationship between technology stack nodes and code structures and project requirement features; The best technology stack recommendation unit combines the project requirement feature vector and the technology stack information of the knowledge graph, uses graph neural network to evaluate the matching degree between the technology stack and the code structure, recommends the technology stack based on the collaborative filtering algorithm, and introduces the reinforcement learning feedback mechanism to dynamically optimize the recommendation results.

9. A method for using an intelligent software development assistance system, applied to the intelligent software development assistance system as claimed in claims 1 to 8, characterized in that: The following steps are involved: Step 1: The developer writes the code, and the system automatically analyzes the semantics and style of the original code, parses and normalizes the original code structure, and outputs standardized code that conforms to the project style; Step 2: Analyze the context semantics of the style-optimized code, capture the semantic structure, combine the semantic structure of the current code context with the project requirement feature vector, generate a structured completion code snippet, and output the completion code snippet that is seamlessly integrated with the existing code; Step 3: Based on the dual detection mechanism of grammar rules and performance optimization, the grammar, logic and performance errors in the completed code are captured in real time. According to the error type and historical data, immediate error correction and optimization suggestions are provided to obtain the optimized code. Step 4: Automatically recommend the best technology stack for the project based on project requirement data and optimized code structure; Step 5: Monitor developers’ programming behaviors in real time during the development process, capture abnormal operations and mark potential risks, and generate operation optimization suggestions.

10. The method for using the intelligent software development assistance system according to claim 9, characterized in that: Also includes: Step 6: Integrate the recommended technology stack information, automatically generate test cases that adapt to the technology stack, cover critical paths and high-risk operations, perform semantic analysis on the optimized code and identify potential security vulnerabilities, identify and mark sensitive information in the optimized code or comments, and provide targeted repair solutions.

Images