Ai-driven software framework migration

Abstract

An automated software framework migration system modifies a project built using components of a legacy software framework with components of a newer version of the software framework. The system uses a conversation manager, agents and a machine learning model to perform the migration task. A developer agent is used to develop the migrated code and the reviewer agent verifies the migrated code for build errors. The machine learning model determines the actions that an agent takes to process the migration task. The conversation manager coordinates the communications with the agents and the machine learning model to generate a dynamic migration workflow.

Description

AI-DRIVEN SOFTWARE FRAMEWORK MIGRATIONBACKGROUND

[0001] Software framework migration is the task of replacing source code built using components of a legacy version of a software framework with source code built from components of a newer version of the software framework. A software framework is a platform for building a software application and contains components, such as, a runtime, code libraries (e.g., base class libraries, managed code libraries) , Application Programming Interfaces (APIs) , tools (e.g., compilers, code editors, package managers, code analyzers, decompilers, debuggers, automated testing tools, deployment tools, etc. ) , and programming languages. These components provide a structure within which a developer can easily develop, test, and build a software application.

[0002] The components of a software framework are updated occasionally to support new features, to improve performance, to fix software bugs, to adapt to changes in APIs, and to become compatible with new tools. The task of migrating a software application from a legacy framework to a newer version of the framework is challenging for large or intricate projects. often relying on manual input to resolve build errors.SUMMARY

[0003] This Summary is provided to introduce a selection of concepts in a simplified form that are further described below in the Detailed Description. This Summary is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to be used to limit the scope of the claimed subject matter.

[0004] An automated software migration system provides for autonomously migrating a software project built using components of a legacy framework to a new version of the framework.

[0005] In an aspect, the automated software framework migration system modifies a project, consisting of software files used to build an application, from a legacy software framework to a newer version of the software framework. The project contains files that utilized components of the legacy software framework that are obsolete. The migration system provides an autonomous workflow to perform the migration through a chatbot that uses a conversation manager, agents and a machine learning model.

[0006] A developer agent is used to develop the migrated code and a reviewer agent verifies the migrated code for build errors. A machine learning model determines the actions that one of the agents needs to perform to process the migration task. A conversation manager coordinates the communications with the agents and the machine learning model to generate a dynamic migration workflow.

[0007] These and other features and advantages will be apparent from a reading of the following detailed description and a review of the associated drawings. It is to be understood that both the foregoing general description and the following detailed description are explanatory only and are not restrictive of aspects as claimed.BRIEF DESCRIPTION OF DRAWINGS

[0008] Fig. 1 is a schematic diagram illustrating an exemplary AI-driven software framework migration system.

[0009] Figs. 2A-2B are schematic diagrams of an exemplary schema used to configure the rules and actions of the agents.

[0010] Figs. 3A-3C are flow diagrams illustrating an exemplary method of the AI-driven software framework migration system.

[0011] Fig. 4 is a schematic diagram of an exemplary breaking change triplet.

[0012] Figs. 5A-5E illustrate an exemplary autonomous flow of the AI-driven software framework migration for an exemplary migration task.

[0013] Fig. 6 is a block diagram illustrating an exemplary operating environment.DETAILED DESCRIPTION

[0014] Overview

[0015] Aspects of the present disclosure pertain to the autonomous migration of a software project from a legacy software framework to a newer version of the software framework. The migration may be caused by the elimination of features in the legacy software framework that are no longer supported by an operating system, caused by changes in the underlying hardware, caused by changes in a programming language, or caused by changes in a component of the underlying software framework used to build the software project. The aim of the migration is to modify the source code to utilize components of the newer software framework while keeping the behavior of the source code unchanged.

[0016] The technique disclosed herein is advantageous over prior solutions that relied on a developer’s skill in knowing the actions needed to migrate source code to a different software framework. A developer would need to know the differences between the current software framework and the new software framework, the intricacies of the source code in the project, and how to alter the individual source code files to account for the changes in the new software framework. Due to the numerous types of changes that can be present in the new software framework, a successful migration would hinge on the developer’s knowledge and skill which is not always possible. A machine learning model has the capability to plan the actions needed for a migration task having been trained on a large corpus of data thereby providing enhanced accuracy. The use of the machine learning model enables the migration task to be planned and performed by a developer not familiar with the nuances of each version of each software framework.

[0017] Machine learning models at times are known to go off track and to hallucinate. The chatbot uses a schema that defines the actions that the model may use in the migration. Each conversation with the chatbot contains the role the model is to assume and the actions that the model may perform. In this way, the model is constrained to using predetermined actions in order to ensure that the model does not drift away to perform other tasks or hallucinate. In this manner, user privacy and file security are preserved since the model is constrained to the actions listed in the schema.

[0018] Aspects of the subject matter disclosed pertain to the technical problem of autonomously performing a software framework migration task. The technical features associated with addressing this problem include a conversation manager that generates conversations with a language model for the model to determine the actions needed to perform the migration task. The technical effect achieved is the improved accuracy in performing the migration and in particular for providing fixes for the build errors that occur in the migration. The use of the language model improves the performance of the migration task since the model is more efficient at analyzing various types of data which is essential for determining the actions needed to perform the migration task and to generate the fixes for the build errors.

[0019] In an aspect, a legacy framework may include a particular set of APIs that is no longer supported in a newer version of the software framework. A project may include source code files that utilize the legacy APIs. The software framework mitigation technique disclosed herein automatically rewrites the code using the legacy APIs with source code that uses APIs in the new software framework that provide a similar function. The project is then compiled, built and verified to ensure that there are no build errors.

[0020] In an aspect, the migration process is performed by a chatbot that communicates with a developer, agents, and a machine learning model. The developer communicates with the chatbot in natural language. The developer initiates the migration task and at times, provides feedback on resolving unresolved build errors. The chatbot engages with the machine learning model for the model to determine the actions needed at a particular point in the migration. The chatbot then invokes either the developer agent or the reviewer agent to perform the model-generated action. In one embodiment, the developer agent and the reviewer agent are software components embodied as separate classes that are called with a distinct API. The reviewer agent builds the project in a docker container using the new software framework and verifies the migration by compiling and generating a package of the project. Build errors that develop during the build are resolved by the developer agent. The developer agent uses the machine learning model to generate a fix for each build error and generates migrated code using the fix. The developer agent generates an input to the model that includes a breaking change triplet.

[0021] A breaking change is a change that affects the behavior of a software component in the new version of a software framework that requires an application to be updated to avoid disruptions. The breaking change triplet includes a description of the breaking change, a description of the previous behavior of the breaking change and a recommendation on how to repair the breaking change in the new software framework. In essence, the breaking change triplet represents a similar build error and a description of how it was fixed. The breaking change triplet is a hint for the model to use when generating a fix for a similar build error. The breaking change triplet is accessed by matching an embedding of the description of a build error with an embedding of the description of the breaking change. The embeddings are generated by an encoder.

[0022] The actions of the developer agent and the reviewer agent are performed in a secure execution environment, such as a docker container. The developer agent generates the migrated code in the docker container and the reviewer agent compiles and builds the entire project in the docker container ensuring a secure environment for the migration.

[0023] Attention now turns to a more detailed description of the components, methods, processes, and system for AI-driven software framework migration.

[0024] System

[0025] Fig. 1 illustrates a block diagram of an exemplary automated AI-driven software framework mitigation system 100. In an aspect, the system 100 is configured as a migration chatbot 102 that interacts through conversations with a user (i.e., developer, programmer, etc. ) , the build and reviewer agents 108, 110, and a language model 114.

[0026] The chatbot 102 is a software program that consists of executable instructions The chatbot 102 uses other software components, such as a conversation manager 104, a developer agent 108, and a reviewer agent 110 to perform specific tasks in the migration process. The conversation manager 104 interacts with a language model 114 to obtain an action to be performed at a particular point in the migration process by either the developer agent or the reviewer agent. The conversation manager 104 invokes the developer agent 108 to generate the migrated source code and the reviewer agent 110 builds the project with the migrated source code and checks that a new version of the software meets the specified requirements and functions as intended. A “build” involves compiling the source code files of the project and generating a package containing the compiled code, related files, and metadata bundled together as a single unit.

[0027] The docker container 112 is a secure execution environment within which the developer agent 108 generates the migrated code and where the reviewer agent 110 compiles, builds and verifies the migrated project. The docker container 112 is isolated from the rest of the system executing in a separate process with all the files it needs to execute. Code development tools 134, such as compilers and build components are used in the docker container 112 in order to isolate the migration task from other processes. The files of a project or code repository 136 are accessed and modified in the docker container 112 to provide a secure environment from unauthorized entities.

[0028] The conversation manager 104 guides the conversations with the user 112, agents, 108, 100 and the language model 114. A conversation is the list of messages or communications made with the chatbot during the migration task. The conversation manager 104 tracks these messages in chronological order in a conversation log 120. The conversation log 120 includes all the messages created and received by the conversation manager which include the request to perform the migration task by the user 116, messages sent to an agent and received from an agent, and the prompts sent to a model and the model responses.

[0029] The conversation log 120 is sent in each prompt or input to a machine language model. The communications with the language model are asynchronous since the language model does retain the state of the previous inputs and model responses. As such, each prompt to the language model and its model output is saved in chronological order in the conversation log. Each prompt issued to the language model includes the past conversations to provide the language model with the past context needed to continue the conversation.

[0030] It should be noted that the input to a language model may be in the form of a prompt which is a question or instruction given to a machine learning model to guide its response and tell it what task to perform. The prompt is the input that initiates the model's processing and determines the output that the model returns. The term prompt, when used with respect to input for a language model, refers to an input to a language model.

[0031] The conversation manager 104 uses a prompt generator 122 to generate the prompts or inputs to the machine language models 114 and to receive the model responses. The conversation manager 104 interacts with the user by sending a message when the migration is completed. The conversation manager uses an output engine 124 to generate and send the completion message 118 to the user.

[0032] The prompt generator 122 generates an input to the language model that includes the role the model is to assume, the actions from the schema 106 that the model can use, and the target task. The schema 106 defines the role of the agents, and the actions permitted by an agent. Each agent is configured with permissions and capabilities indicated by the rules and actions in the schema. The schema 106 contains the natural language instructions that may be used by an agent.

[0033] The developer agent 108 uses a configuration migrator 126 to develop a new project file for the migrated project and a file-level code migrator 128 to generate the migrated source code using a language model 114. A more detailed description of the configuration manager 126 and the file-level code migrator 128 is found below.

[0034] The developer agent 108 also generates a fix to remedy a build error detected by the reviewer agent 110 using the language model 114 given the build error and information on how previous build errors were fixed. The developer agent 108 searches a database of build repairs 130 to obtain information on previous build errors. The database 130 is indexed with an embedding of the description of the build error. The embedding is generated by an encoder 132. These components of the developer agent 108 are described in more detail below.

[0035] The reviewer agent 110 uses a build engine 138 to compile the migrated source code and build the project in the docker container 112. The reviewer agent 110 uses an error detection engine 140 to identify any build errors resulting from the compilation of the migrated code and the project build. The error detection engine 140 uses a language model to identify the build errors. These components of the reviewer agent 110 are described in more detail below.

[0036] In an aspect, the language model 114 is a deep learning model. Machine learning pertains to the use and development of computer systems that are able to learn and adapt without following explicit instructions by using algorithms and statistical models to analyze and draw inferences from patterns in data. Machine learning uses different types of statistical methods to learn from data and to predict future decisions. Traditional machine learning includes classification models, data mining, Bayesian networks, Markov models, clustering, and visual data mapping.

[0037] Deep learning differs from traditional machine learning since it uses multiple stages of data processing through many hidden layers of a neural network to learn and interpret the features and the relationships between the features. Deep learning embodies neural networks which differs from the traditional machine learning techniques that do not use neural networks. Neural transformers models are one type of deep learning that utilizes an attention mechanism. Attention directs the neural network to focus on a subset of features or tokens in an input sequence thereby learning different representations from the different positions of the tokens in an input sequence. The neural transformer model handles dependencies between its input and output with attention and without using recurrent neural networks (RNN) (e.g., long short-term memory (LSTM) network) and convolutional neural networks (CNN) .

[0038] Examples of a language model include the encoder and generative neural transformer models with attention (i.e., encoder-decoder, decoder) offered by OpenAI (i.e., ChatGPT and Codex models) , PaLM, Chinchilla, and the Bidirectional Encoder Representations from Transformers (BERT) offered by Google, the Gemini multi-modal models of Google, LLaMa by Meta, and the Phi-3 models offered by Microsoft.

[0039] In an aspect, the language model 114 is a generative neural transformer model with attention (e.g., encoder-decoder, decoder) . The language model 114 is hosted on an external server and accessed over a network through application programming interfaces (API) . The prompt to a language model may be issued through HTTP-based Representational State Transfer (REST) APIs. A REST API or web API is an API that conforms to the REST protocol. In the REST protocol, the remote server hosting the language model contains a publicly-exposed endpoint having a defined request and response structure. The prompt generator 122 issues web APIs containing an input to the remote server to instruct the large language model to perform the intended task for the given input.

[0040] Attention now turns to a more detailed explanation of the actions of the developer and reviewer agents. Turning to Figs. 2A -2B, there is shown an exemplary schema showing the rules and actions for the developer and review agents 200. In an aspect, the schema is written in a Yet Another Markup Language (YAML) file.

[0041] The schema 200 defines the available actions that an agent can initiate. A developer of the chatbot can leverage the default settings or fine-grained permissions by enabling or disabling specific actions thereby tailoring the chatbot to a specific configuration.

[0042] The configuration shown in Fig. 2A shows the developer agent 201 and the configuration shown in Fig. 2B shows the reviewer agent 203. Each agent contains a name 202, 210, a system message 204, 212, instructions 206, 214, and commands or actions 208, 216. The name 202, 210 identifies the role of the agent, the system message 204, 212 specifies the behavior of the agent, the instructions 206, 214 indicate the high-level instructions the agent needs to follow in natural language, and the commands or actions 208, 216 are the operations that the agent can initiate. The system prompt, instructions, and available actions will be provided to each individual agent as the first part of their prompt, followed by the task, and the rest of the conversation. With each action, there is an enabled field which contains either a true or false value. The true value indicates that action is enabled and the false value disengages the action. The enabled field is set by the user.

[0043] The developer agent 201 is used to facilitate actions of a developer in migrating the code in a file. The actions associated with this agent include migrate_config, migrate_code, ask_for_action and stop. The migrate_config action migrates the project configuration file, the migrate_code action migrates the files in the project, the ask_for_action asks the developer to fix a build error, and the stop action terminates the migration.

[0044] The reviewer agent 203 is used to facilitate the actions used to review source code generated by the developer agent. The actions 216 associated with the reviewer agent 203 include build_and_diff, check_remaining_errors and stop. The build_and_diff action builds the project and finds migration or build errors, the check_remaining_errors action searches for build errors that have not been resolved, and the stop action signals to the conversation manager to cease processing when the migration task is completed.

[0045] Methods

[0046] Attention now turns to a more detailed description of the methods used in the system for code review generation. It may be appreciated that the representative methods do not necessarily have to be executed in the order presented, or in any particular order, unless otherwise indicated. Moreover, various activities described with respect to the methods can be executed in serial or parallel fashion, or any combination of serial and parallel operations. In one or more aspects, the method illustrates operations for the systems and devices disclosed herein.

[0047] Figs. 3A-3C illustrate an exemplary method of the AI-driven software development system 300. Initially, the user of the system inputs the schema to the conversation manager 104 (block 302) . The conversation manager 104 uses the schema to form an input to the language model that instructs the model to perform the role of either the developer agent 108 or the reviewer agent 110 as described in the schema (block 302) .

[0048] The developer initiates the migration task by sending a natural language description of the migration task to the conversation manager 104 (block 304) . The migration task includes the name of the project or repository to be migrated and the new software framework that the project is migrated to.

[0049] The conversation manager 104 generates a database of build repairs 130 that stores previously generated code migrated into the new software framework (block 306) . The data for the database 130 is extracted from various online documents describing changes made to code from a legacy software framework to each new version of a software framework.

[0050] In an aspect, a breaking change is a change that affects the behavior of an API in the new framework version that requires an application to be updated to avoid disruptions. An API is a type of a software interface and any change in its definition, public members, member names, changes to a base type, adding / removing interfaces from list of implemented interfaces of the API, adding / removing members, changing member visibility, renaming method and type parameters, adding default values for method parameters, adding / removing attributes on types and members, and adding / removing generic type parameters on types and members requires the API to be upgraded to the new framework version. In addition, any change that affects the behavior of the API, such as changes in the security protocol or authentication method used by an API, changing the functionality of an endpoint associated with the API, changes in the error codes for an API, etc. also requires migration.

[0051] The database of build repairs 130 contains information regarding each breaking change for a particular framework version. Each entry in the database 130 includes a description of the breaking change, the previous behavior, and a recommended action. The previous behavior describes a legacy implementation of the breaking change and the recommended action describes how to migrate source code affected by the breaking change to avoid the breaking change.

[0052] The database of build repairs 130 is indexed by an embedding of a description of a breaking change. The embedding is produced by an encoder, such as the Bidirectional Encoder Representations from Transformers (BERT) . Each entry in the database 130 comprises a breaking change triplet consisting of the breaking change description, the previous behavior, and a recommended action.

[0053] Turning to Fig. 4, there is shown an illustration of an exemplary breaking change triplet. The breaking change triplet 400 shown pertains to the endpoint routing in ASP. NET Core 3.1. An endpoint is the address within an API that allows a client application to send requests and receive responses.

[0054] The description of the breaking change 402 indicates a change to the endpoint routing authorization of the software framework, ASP. NET Core 3.1. The previous behavior 404 indicates how the endpoint routing was performed in the legacy framework. The recommendation 406 indicates how to migrate legacy code using the endpoint routing into the newer version of the framework.

[0055] Turning back to Fig. 3A, the conversation manager 104 obtains the actions for performing the migration task using the language model 114. The conversation manager 104 generates a prompt or input to the language model 114 for the model 114 to indicate which agent and action to initiate to execute the user’s migration task (block 308) . The model response indicates that the developer agent 108 is to perform the migrate_config action (block 308) . The migrate_config action or configuration migration refers to migrating the project file of the project being migrated. The conversation manager 104 instructs the developer agent 108 to perform the configuration migration (block 310) .

[0056] A project refers to a collection of files, libraries, assets, and other resources needed of build a software application, website or library. A project may also be a source code repository. The project is a single unit that contains the content to include in the software application, website or library, the platform requirements, versioning information, settings for a web server or database server, and the tasks that must be performed by a build engine. Each project is represented by a specific project file. The project file is an XML document that contains all the information about the project structure, dependencies, build settings needed for the build engine 138 to build the project. In essence, the project file represents the configuration of the project. For C# projects, the project file is a . csproj file.

[0057] The first step in migrating a project to a new framework version, is to migrate the project file to the new framework version (block 310) . The project file is used by the build engine 138 (e.g., MSBuild) to compile the code in the project, to link to other code referenced in the project and to create an executable package of the project. The current format of the project file may differ from the format used in the new framework version thereby requiring the current project file to be formatted in accordance with the new format. A reference in the project file to the target framework is updated to the new framework version. Dependencies and references in the current project file may need to be upgraded to newer versions that are compatible with the new framework version. Elements in the current project file that are no longer supported are removed or modified.

[0058] Upon the conversation manager 104 receiving notification from the developer agent 108 of the completion of the configuration migration (block 310) , the conversation manager 104 requests the language model 114 to determine the next action to be performed (block 312) . The language model 114 responds by indicating that the reviewer agent 110 is to perform the build_and_diff action. The build_and_diff action builds the project and reports any errors encountered in the build process.

[0059] The conversation manager 104 initiates the reviewer agent 110 to perform the build_and_diff action (block 312) . Upon completion of the build_and_diff action by the reviewer agent 110, the reviewer agent 110 informs the conversation manager 104 of the status of the build process and the list of build errors (block 314) . Each build error contains a file path of the file containing the error, the line number in the file of the error, and the error description (block 314) .

[0060] The conversation manager 104 then requests the language model 114 to determine the next step (block 316) . The language model 114 is given the current state of the conversation, the list of build errors, and the location of the code attributable to the build error. The model 114 responds by indicating that the developer agent 108 is to perform file-level migration for the build errors (block 316) . The conversation manager 104 instructs the developer agent 108 to perform file-level migration by fixing each build error thereby migrating the source code associated with each build error to the new software framework (block 318) .

[0061] The developer agent 108 processes each build error one at a time (block 320) . The developer agent 108 instructs the language model 114 to generate a repair for each build error (block 322) . The prompt to the language model includes the migration software framework version, the source code context and a breaking change triplet corresponding to the source code context of the build error. The breaking change triplet had a similar build error and a known fix, which is used to guide the language model towards generating a more precise output.

[0062] The developer agent 108 obtains the location of the build error from the error message generated by the reviewer agent 110. Each error message contains the file path of the location of the file containing the error, the line number of the source code containing the error, and a description of the error.

[0063] The following is an example of an error message:

[0064] C: \\Users\\lixiaoyu\\UpgradeSample\\Incremental\\01-Start\\eShopLegacy. Common\\Utilities\\Serializing. cs: error CS1061: BinaryFormatter does not contain a definition for UnsafeDeserialize and no accessible extension method UnsafeDeserialize accepting a first argument of type BinaryFormatter could be found (are you missing a using directive or an assembly reference? ) at line 21.

[0065] The error message indicates that the file containing the error is: C: \\Users\\lixiaoyu\\UpgradeSample\\Incremental\\01-Start\\eShopLegacy. Common\\Utilities\\Serializing. cs. The line number of the error is line 21. The description of the error is “error CS1061: BinaryFormatter does not contain a definition for UnsafeDeserialize and no accessible extension method UnsafeDeserialize accepting a first argument of type BinaryFormatter could be found (are you missing a using directive or an assembly reference? ) . ”

[0066] The source code surrounding the build error is used as the context of the build error. The developer agent 108 generates an embedding of the description of the build error using an encoder 132 and the embedding is used as an index into the database of build repairs 130 to extract a corresponding breaking change triplet.

[0067] In response to the developer agent 108 instructing the language model to generate the repair for a build error, the model 114 responds with source code to repair the build error. The developer agent 108 modifies the source code with the repair in the docker container 112 (block 322) .

[0068] Upon the completion of the fixes to the build errors, the developer agent 108 returns the status of the fixes to the build errors to the conversation manager 104 (block 324) . The conversation manager 104 then requests the model 114 to determine the next action to be performed (block 326) . The model 114 responds with the reviewer agent 110 performing the build_and_diff action (block 326) .

[0069] The conversation manager 104 instructs the reviewer agent 108 to perform the build_and_diff action to verify that there are no errors (block 328) . The reviewer agent 110 performs the build process in the docker container 112 (block 328) . When the build process determines that there are no errors in the migrated code (block 330-no) , the conversation manager 104 requests the model 114 to determine the next action (block 332) . The model 114 responds with the reviewer agent 110 executing the stop action which terminates the migration process (block 332) . The output engine 124 then sends a completion message to the user indicating that the migration is completed (block 332) .

[0070] If the reviewer agent 110 determines that errors exist (block 330-yes) , then the conversation manager 104 requests that the language model 114 determine the next step to perform (block 334) . The model 114 responds by indicating that the reviewer agent 110 is to perform the check_remaining_errors action (block 334) . The conversation manager 104 initiates the reviewer agent 110 to perform the check_remaining_errors action which compares the original list of build errors to find outstanding build errors or follow-up errors (block 336) .

[0071] If build errors from the original list exist (block 337-yes) , then the method continues with the file-level migration (block 316) . If there are no build errors but follow-up errors exist (block 338-yes) , then the developer agent 108 engages with the user (block 340) . Otherwise, if there are no build errors or follow-up errors (block 337-no, block 338-no) , the conversation terminates (block 354) .

[0072] If follow-up errors exist (block 338-yes) , then the configuration manager 104 generates an input to the language model 114 for the model to determine the next action. The model responds indicating that the developer agent 108 should execute the ask_for_action action to fix the remaining follow-up errors (block 340) . The ask-for_action action prompts the user for assistance in generating a repair for a follow-up error. The prompt to the user includes a suggested model-generated repair.

[0073] The developer agent 108 generates an input to the language model 114 requesting the suggested repair code for each of the follow-up errors (block 342) .

[0074] The language model 114 generates the repair code (block 344) . The developer agent 108 communicates with the user regarding the use of the repair code (block 346) . When the user accepts the suggested repair code (block 348-yes) , the developer agent 108 uses the suggested repair code to fix the follow-up error (block 352) . The user may input user-generated repair code instead of using the suggested repair code (block 348-no) . In this case, the developer agent 108 uses the user-generated repair code to fix the follow-up error (block 352) .

[0075] Upon completion of the follow-up error fixes, the conversation manager 104 requests that the language model 114 determine the next action (block 354) . The model responds indicating that the developer agent 108 should execute the stop action which terminates the conversation (block 354) .

[0076] Attention now turns to an illustration of an exemplary chatbot conversation for a migration.

[0077] Exemplary Illustration

[0078] Figures 5A-5E illustrate an exemplary conversation to migrate a target project into the software framework of . NET 7.0. The . NET framework is a software framework consisting of a suite of developer tools designed to develop, test, and build software applications that run under the Windows operating systems. It should be noted that the technique described herein is not limited to the . NET framework and that technique may be used on other frameworks or developer platforms.

[0079] The conversation starts when a user inputs a migration task, such as “Migrate <target project> to Net7.0” to the chatbot (block 502) . The conversation manager 104 generates an input to the language model 114 for the language model to determine the action to perform the user’s migration task (block 504) . The prompt generator 122 constructs a prompt that provides the model with instructions, such as the role of the developer agent 503 and the model’s task 505.

[0080] The model 122 responds with the developer action, migrate_config net7.0, which is the migration of the project’s configuration file (block 506) . When the developer agent 108 completes the configuration migration, the developer agent 108 returns a message to the conversation manager 104 indicating the exemplary configuration migration was successful (block 508) .

[0081] The configuration manager 104 then generates an input for the language model 114 to determine the next action to be performed (block 510) . The prompt generator 122 generates a prompt or input that includes the reviewer’s role 511, instructions, and the conversation log 513. The reviewer’s role 511 informs the language model 114 of the role the language model 114 is assuming, the instructions indicate that the model 114 is to generate the next action, and the conversation log 120 provides the state of the current conversation. The language model 114 responds with the reviewer action, build_and_diff (block 512) .

[0082] The conversation manager 104 invokes the reviewer agent 110 to build the project which comprises compiling and building the source code files of the project using the libraries and tools of the . NET 7.0 framework (block 514) . The project build is performed in the docker container 112. The output of the build action is a list of build errors. In the example shown in block 514, there are several build errors. The build error message contains the file path of the file causing the error, the error, and the line number of the error in the file.

[0083] The conversation manager 104 then generates an input to the language model 114 for the model to determine the next action (block 516) . The prompt to the model is similar to the prompt shown in block 504 except with the current state of the conversation and instructions for the model to determine for the next action. The model 114 responds with a description of how each build error can be fixed (block 518) .

[0084] The conversation manager 104 invokes the developer agent 108 to generate the repair code for each build error (blocks 519, 520) . The developer agent 108 generates an input to the language model 114 for the model to generate the source code that implements the model-generated description of the repair. The developer agent 108 obtains code fixes from the database of build repairs using the error message generated from the model (block 519) . The code fixes from the database of build repairs are a hint for the language model 114 to generate the repair code. The prompt includes the migration task, the source code containing the error, the hint found in the database of build repairs, and instructions to generate C# source code. The language model 114 responds with the C# repair code (block 522) .

[0085] The conversation manager 104 generates an input to the model for the model to determine the next action in a prompt that includes the reviewer agent’s role, the current state of the conversation log, and instructions (block 524) . The language model 114 responds with the reviewer action, build_and_diff (block 526) . The reviewer agent 110 builds the project in the docker container by compiling all the files in the project and generating a package (block 528) . The reviewer agent 110 finds new errors (block 528) .

[0086] The conversation manager 104 generates an input to the language model 114 for the model to determine the next action given the new errors (block 530) . The language model 114 responds with the reviewer agent action of check_remaining_errors (block 532) . The reviewer agent 110 checks for remaining errors and finds one (block 534) . The conversation manager 104 generates an input to the language model 114 for the model to determine the next action which is for the developer agent 108 to fix the remaining error (block 536) . The language model 114 responds by indicating that the developer agent 108 is to perform the ask_for_action action (block 538) .

[0087] The ask_for_action action obtains a suggested fix from the language model 114 which is then sent to the user to approve or edit (block 540) . The prompt to the language model 114 for the suggested fix to the user includes the error, the context of the error, the code changes that caused the error, and the conversation log (not shown) . The language model 114 responds with the suggested code fix (block 542) . The developer agent 108 sends a message to the user for the user’s assistance (block 544) . The message contains the suggested code fix and instructions. The user responds with “Done” indicating that the suggested code fix will fix the error (block 546) . The developer agent 108 modifies the error with the suggested code fix.

[0088] The conversation manager 104 then generates an input to the language model 114 for the model to determine the next action (block 548) and the language model 114 responds with the stop action (block 550) . The developer agent 108 performs the stop action which ends the conversation (block 552) .

[0089] Operating Environments

[0090] Attention now turns to a discussion of an exemplary operating environment 600. Fig. 6 illustrates an exemplary operating environment 600 having computing devices 602, 604, 608 communicatively coupled to a network 606. In one aspect, the chatbot may be hosted on one computing device 604, the language models hosted on another computing device 608 and the user communicating through a chat bot user interface hosted on another computing device 602. In another aspect, all the components of the AI-driven software framework migration system may be hosted on the same computing device. However, the aspects of the operating environment are not constrained to a particular configuration and the components of the AI-driven software framework migration system may be configured as desired.

[0091] The computing devices 602, 604, 608 may be any type of electronic device, such as, without limitation, a mobile device, a personal digital assistant, a mobile computing device, a smart phone, a cellular telephone, a handheld computer, a server, a server array or server farm, a web server, a network server, a blade server, an Internet server, a work station, a mini-computer, a mainframe computer, a supercomputer, a network appliance, a web appliance, a distributed computing system, multiprocessor systems, or combination thereof. The operating environment 600 may be configured in a network environment, a distributed environment, a multi-processor environment, or a stand-alone computing device having access to remote or local storage devices.

[0092] A computing device 602, 604, 608 may include one or more processors 610, 628, 650, one or more communication interfaces 612, 630, 652 one or more storage devices 614, 632, 654, one or more input / output devices 616, 634, 656, and one or more memory devices 618, 636, 658. A processor 610, 628, 650 may be any commercially available or customized processor and may include dual microprocessors and multi-processor architectures. A communication interface 612, 630, 652 facilitates wired or wireless communications between the computing device 602, 604, 608 and other devices. A storage device 614, 632, 654 may be computer-readable medium that does not contain propagating signals, such as modulated data signals transmitted through a carrier wave. Examples of a storage device 614, 632, 654 include without limitation RAM, ROM, EEPROM, flash memory or other memory technology, CD-ROM, digital versatile disks (DVD) , or other optical storage, magnetic cassettes, magnetic tape, magnetic disk storage, all of which do not contain propagating signals, such as modulated data signals transmitted through a carrier wave. There may be multiple storage devices 614, 632, 654, in a computing device 602, 604, 608. The input / output devices 616, 634, 656 may include a keyboard, mouse, pen, voice input device, touch input device, display, speakers, printers, etc., and any combination thereof.

[0093] A memory device 618, 636, 658 may be any non-transitory computer-readable storage media that may store executable procedures, applications, and data. The computer-readable storage media does not pertain to propagated signals, such as modulated data signals transmitted through a carrier wave. It may be any type of non-transitory memory device (e.g., random access memory, read-only memory, etc. ) , magnetic storage, volatile storage, non-volatile storage, optical storage, DVD, CD, floppy disk drive, etc. that does not pertain to propagated signals, such as modulated data signals transmitted through a carrier wave. A memory device 618, 636, 658 may also include one or more external storage devices or remotely located storage devices that do not pertain to propagated signals, such as modulated data signals transmitted through a carrier wave.

[0094] The memory device 618, 636, 658 may contain instructions, components, and data. A component is a software program that performs a specific function and is otherwise known as a module, program, component, and / or application. The memory device 618 may include an operating system 620, a chatbot user interface 622, and other applications and data 626. Memory device 636 may include an operating system 638, one or more language models 640, and other applications and data 642. Memory device 658 may include an operating system 660, a conversation manager 662, a conversation log 664, a prompt generator 666, an output engine 668, a schema 670, a developer agent 672, a reviewer agent 674, a docker container 676, and other applications and data 678.

[0095] The computing devices 602, 604, 608 may be communicatively coupled via a network 606. The network 606 may be configured as an ad hoc network, an intranet, an extranet, a virtual private network (VPN) , a local area network (LAN) , a wireless LAN (WLAN) , a wide area network (WAN) , a wireless WAN (WWAN) , a metropolitan network (MAN) , the Internet, a portion of the Public Switched Telephone Network (PSTN) , plain old telephone service (POTS) network, a wireless network, a network, or any other type of network or combination of networks.

[0096] The network 606 may employ a variety of wired and / or wireless communication protocols and / or technologies. Various generations of different communication protocols and / or technologies that may be employed by a network may include, without limitation, Global System for Mobile Communication (GSM) , General Packet Radio Services (GPRS) , Enhanced Data GSM Environment (EDGE) , Code Division Multiple Access (CDMA) , Wideband Code Division Multiple Access (W-CDMA) , Code Division Multiple Access 2000, (CDMA-2000) , High Speed Downlink Packet Access (HSDPA) , Long Term Evolution (LTE) , Universal Mobile Telecommunications System (UMTS) , Evolution-Data Optimized (Ev-DO) , Worldwide Interoperability for Microwave Access (WiMax) , Time Division Multiple Access (TDMA) , Orthogonal Frequency Division Multiplexing (OFDM) , Ultra Wide Band (UWB) , Wireless Application Protocol (WAP) , User Datagram Protocol (UDP) , Transmission Control Protocol / Internet Protocol (TCP / IP) , any portion of the Open Systems Interconnection (OSI) model protocols, Session Initiated Protocol / Real-Time Transport Protocol (SIP / RTP) , Short Message Service (SMS) , Multimedia Messaging Service (MMS) , or any other communication protocols and / or technologies.

[0097] Conclusion

[0098] One of ordinary skill in the art understands that the techniques disclosed herein are inherently digital. The operations used to perform the autonomous processing including, without limitation, invoking the language models to perform specific tasks, build a project in a docker container, developing code in a docker container, and managing the conversational flow are inherently digital. The human mind cannot interface directly with a CPU or network interface card, or other processor, or with RAM or other digital storage, to read or write the necessary data and perform the necessary operations disclosed herein.

[0099] The embodiments are also presumed to be capable of operating at scale, within tight timing constraints in production environments and in testing labs for production environments as opposed to being mere thought experiments. Hence, the human mind cannot perform the operations described herein in a timely manner and with the accuracy required for these intended uses.

[0100] Although the subject matter has been described in language specific to structural features and / or methodological acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or acts described above. Rather, the specific features and acts described above are disclosed as example forms of implementing the claims.

[0101] It may be appreciated that the representative methods described herein do not necessarily have to be executed in the order presented, or in any particular order, unless otherwise indicated. Moreover, various activities described with respect to the methods can be executed in serial or parallel fashion, or any combination of serial and parallel operations.

[0102] A system is disclosed for migrating a project from a first version of a software framework to a second version of the software framework, comprising: a processor; and a memory that stores a program that is configured to be executed by the processor. The program includes instructions to perform actions that: receive, using a chatbot, a user request to migrate the project to the second version of the software framework, wherein the chatbot comprises a developer agent and a reviewer agent, wherein the project comprises a plurality of files; cause a language model to determine a first action to perform the migration, wherein the language model is given the user request; obtain from the language model the first action, wherein the first action instructs the reviewer agent to build the project in the second version of the software framework, wherein the building of the project comprises compiling the plurality of files in the second version of the software framework and generating a package of the project; obtain a first build error, from the reviewer agent, resulting from the building of the project in the second version of the software framework; cause the language model to determine a second action to fix the first build error, wherein the language model is given the first build error; and obtain from the language model the second action that instructs the developer agent to generate the fix for the first build error by performing acts that: retrieve a hint for the first build error from a database of build repairs, wherein the hint comprises a description of a similar build error to the first build error and a repair for the similar build error; extract a context of the first build error from one of the plurality of files of the project; cause the language model to generate a first repair to fix the first build error, wherein the language model is given the first build error, the context of the first build error and the hint; and modify the one of the plurality of files having the first build error with the first repair.

[0103] In an aspect, the program includes instructions to perform actions that: cause the language model to determine a next action to continue the migration after completion of the second action; obtain from the language model a third action for the reviewer agent to build the project with the first repair and verify that the first repair in the one of the plurality of files compiled successfully.

[0104] In an aspect, the program includes instructions to perform actions that: determine from the reviewer agent, that the compilation of the first model-generated repair caused a second build error; and cause the language model to determine a fourth action to fix the second build error.

[0105] In an aspect, the program includes instructions to perform actions that: obtain from the language model, the fourth action for the developer agent to generate a second repair for the second build error; and cause, by the developer agent, the language model to generate the second repair for the second build error.

[0106] In an aspect, the program includes instructions to perform actions that: obtain, by the developer agent, the second repair; output, by the developer agent, the second repair to a user; and upon user acceptance of the second repair, modify, by the developer agent, the one of the plurality of files having the build error with the second repair.

[0107] In an aspect, wherein each entry in the database of build repairs is indexed using an embedding, wherein the embedding is based on a description of a known build error in the first software framework.

[0108] In an aspect, the program includes instructions to perform actions that: search for an embedding in the database of build repairs that is similar to an embedding of a description of a first build error by matching the embedding of the description of the first build error with each embedding in the database of build repairs.

[0109] A computer-implemented method for migrating a project from a first version of a software framework into a second version of the software framework is disclosed, comprising: receiving, at a chatbot, a natural language request to migrate a project to the second version of the software framework, wherein the project comprises a plurality of files; causing a language model to determine a first action to perform the migration, wherein the language model is given the natural language request; obtain from the language model the first action for a reviewer agent to build the project in the second version of the software framework; detecting, by the reviewer agent, a first build error in the building of the project; causing the language model to determine a second action to fix the first build error; and obtaining from the language model the second action for the developer agent to fix the first build error, wherein the developer agent performs acts that fix the first build error by: accessing a hint from a database comprising a plurality of code repairs for build errors associated with migration to the second version of the software framework; causing, by the developer agent, the language model to generate a first repair for the first build error, wherein the language model is given an input comprising the first build error and the hint; and modifying, by the developer agent, one of the plurality of files of the project containing the first build error with the first repair.

[0110] In an aspect, the computer-implemented method further comprises: causing the language model to determine a next action after completion of the second action; obtain from the language model a third action indicating that the reviewer agent is to build the project; and detecting by the reviewer agent, a second build error.

[0111] In an aspect, the computer-implemented method, further comprises: causing the language model to determine a fourth action to fix the second build error; and obtain from the language model the fourth action indicating that the developer agent is to generate the fix to the second build error.

[0112] In an aspect, the computer-implemented method, further comprises: causing the language model to generate a second repair for the second build error given the first build error and the first repair; and obtain the second repair for the second build error.

[0113] In an aspect, the computer-implemented method, further comprises: upon user input accepting the second repair, modifying by the developer agent the one of the plurality of files of the project containing the second build error with the second repair.

[0114] In an aspect, the reviewer agent builds the project using software components of the new version of the software framework in a docker container. In an aspect, the developer agent repairs a file of the plurality of files of the project containing a build error in a docker container.

[0115] In an aspect, the computer-implemented method, further comprises: causing the language model to determine a next action to perform; and obtain from the language model a last action of the developer agent to terminate the migration.

[0116] A hardware storage device is disclosed having stored thereon computer executable instructions that are structured to be executable by a processor of a computing device to thereby cause the computing device to perform actions that migrate a project, comprising a plurality of files, from a first version of a software framework to a second version of the software framework: obtain, at a chatbot, from a natural language user input, a request to migrate the project to the second version of the software framework; cause a language model to determine a first action to perform the migration given the natural language user input; obtain from the language model the first action for the reviewer agent to build the project in the second software framework, wherein the building of the project comprises compiling the plurality of files in the second software framework and generating a package in the second software framework; obtain a first build error from the reviewer agent resulting from the building of the project in the second software framework; cause the language model to determine a second action to fix the first build error; and obtain from the language model the second action indicating for the developer agent to fix the first build error by performing acts that: retrieve a hint for the first build error from a database of build repairs, wherein the hint comprises a description of a similar build error to the first build error and a repair for the similar build error; extract a context of the first build error in one of the plurality of files of the project; cause the language model to produce a first repair to fix the first build error, wherein the language model is given the first build error, the context of the first build error and the hint; and modify the one of the plurality of files having the first build error with the first repair.

[0117] In an aspect, the hardware storage device has stored thereon computer executable instructions that are structured to be executable by a processor of a computing device to thereby cause the computing device to perform further actions that: cause the language model to determine a next action to continue the migration; obtain from the language model a third action for the reviewer agent to build the project with the first repair and to verify that the first repair in the one of the plurality of files compiled successfully.

[0118] In an aspect, the hardware storage device has stored thereon computer executable instructions that are structured to be executable by a processor of a computing device to thereby cause the computing device to perform further actions that: determine from the reviewer agent, that the compilation of the first repair causes a second build error; and cause the language model to determine a fourth action to fix the second build error.

[0119] In an aspect, the hardware storage device has stored thereon computer executable instructions that are structured to be executable by a processor of a computing device to thereby cause the computing device to perform further actions that: obtain from the language model the fourth action indicating that the developer agent is to generate a second repair for the second build error; and cause, by the developer agent, the language model to generate the second repair for the second build error.

[0120] In an aspect, the hardware storage device has stored thereon computer executable instructions that are structured to be executable by a processor of a computing device to thereby cause the computing device to perform further actions that: obtain, by the developer agent, the second repair; output, by the developer agent, the second repair to a user; and upon user acceptance of the second repair, modify, by the developer agent, the one of the plurality of files having the build error with the second repair.

Claims

1.A system for migrating a project from a first version of a software framework to a second version of the software framework, comprising:a processor; anda memory that stores a program that is configured to be executed by the processor, the program includes instructions to perform actions that:receive, using a chatbot, a user request to migrate the project to the second version of the software framework, wherein the chatbot comprises a developer agent and a reviewer agent, wherein the project comprises a plurality of files;cause a language model to determine a first action to perform the migration, wherein the language model is given the user request;obtain from the language model the first action, wherein the first action instructs the reviewer agent to build the project in the second version of the software framework, wherein the building of the project comprises compiling the plurality of files in the second version of the software framework and generating a package of the project;obtain a first build error, from the reviewer agent, resulting from the building of the project in the second version of the software framework;cause the language model to determine a second action to fix the first build error, wherein the language model is given the first build error; andobtain from the language model the second action that instructs the developer agent to generate the fix for the first build error by performing acts that:retrieve a hint for the first build error from a database of build repairs, wherein the hint comprises a description of a similar build error to the first build error and a repair for the similar build error;extract a context of the first build error from one of the plurality of files of the project;cause the language model to generate a first repair to fix the first build error, wherein the language model is given the first build error, the context of the first build error and the hint; andmodify the one of the plurality of files having the first build error with the first repair.2.The system of claim 1, wherein the program includes instructions to perform actions that:cause the language model to determine a next action to continue the migration after completion of the second action;obtain from the language model a third action for the reviewer agent to build the project with the first repair and verify that the first repair in the one of the plurality of files compiled successfully.3.The system of claim 2, wherein the program includes instructions to perform actions that:determine from the reviewer agent, that the compilation of the first model-generated repair caused a second build error; andcause the language model to determine a fourth action to fix the second build error.4.The system of claim 3, wherein the program includes instructions to perform actions that:obtain from the language model, the fourth action for the developer agent to generate a second repair for the second build error; andcause, by the developer agent, the language model to generate the second repair for the second build error.5.The system of claim 4, wherein the program includes instructions to perform actions that:obtain, by the developer agent, the second repair;output, by the developer agent, the second repair to a user; andupon user acceptance of the second repair, modify, by the developer agent, the one of the plurality of files having the build error with the second repair.6.The system of claim 1, wherein each entry in the database of build repairs is indexed using an embedding, wherein the embedding is based on a description of a known build error in the first software framework.7.The system of claim 6, wherein the program includes instructions to perform actions that:search for an embedding in the database of build repairs that is similar to an embedding of a description of a first build error by matching the embedding of the description of the first build error with each embedding in the database of build repairs.8.A computer-implemented method for migrating a project from a first version of a software framework into a second version of the software framework, comprising:receiving, at a chatbot, a natural language request to migrate a project to the second version of the software framework, wherein the project comprises a plurality of files;causing a language model to determine a first action to perform the migration, wherein the language model is given the natural language request;obtain from the language model the first action for a reviewer agent to build the project in the second version of the software framework;detecting, by the reviewer agent, a first build error in the building of the project;causing the language model to determine a second action to fix the first build error; andobtaining from the language model the second action for the developer agent to fix the first build error, wherein the developer agent performs acts that fix the first build error by:accessing a hint from a database comprising a plurality of code repairs for build errors associated with migration to the second version of the software framework;causing, by the developer agent, the language model to generate a first repair for the first build error, wherein the language model is given an input comprising the first build error and the hint; andmodifying, by the developer agent, one of the plurality of files of the project containing the first build error with the first repair.9.The computer-implemented method of claim 8, further comprising:causing the language model to determine a next action after completion of the second action;obtain from the language model a third action indicating that the reviewer agent is to build the project; anddetecting by the reviewer agent, a second build error.10.The computer-implemented method of claim 9, further comprising:causing the language model to determine a fourth action to fix the second build error; andobtain from the language model the fourth action indicating that the developer agent is to generate the fix to the second build error.11.The computer-implemented method of claim 10, further comprising:causing the language model to generate a second repair for the second build error given the first build error and the first repair; andobtain the second repair for the second build error.12.The computer-implemented method of claim 11, further comprising:upon user input accepting the second repair, modifying by the developer agent the one of the plurality of files of the project containing the second build error with the second repair.13.The computer-implemented method of claim 8, wherein the reviewer agent builds the project using software components of the new version of the software framework in a docker container.14.The computer-implemented method of claim 8, wherein the developer agent repairs a file of the plurality of files of the project containing a build error in a docker container.15.The computer-implemented method of claim 12, further comprising:causing the language model to determine a next action to perform; andobtain from the language model a last action of the developer agent to terminate the migration.16.A hardware storage device having stored thereon computer executable instructions that are structured to be executable by a processor of a computing device to thereby cause the computing device to perform actions that migrate a project, comprising a plurality of files, from a first version of a software framework to a second version of the software framework:obtain, at a chatbot, from a natural language user input, a request to migrate the project to the second version of the software framework;cause a language model to determine a first action to perform the migration given the natural language user input;obtain from the language model the first action for the reviewer agent to build the project in the second software framework, wherein the building of the project comprises compiling the plurality of files in the second software framework and generating a package in the second software framework;obtain a first build error from the reviewer agent resulting from the building of the project in the second software framework;cause the language model to determine a second action to fix the first build error; andobtain from the language model the second action indicating for the developer agent to fix the first build error by performing acts that:retrieve a hint for the first build error from a database of build repairs, wherein the hint comprises a description of a similar build error to the first build error and a repair for the similar build error;extract a context of the first build error in one of the plurality of files of the project;cause the language model to produce a first repair to fix the first build error, wherein the language model is given the first build error, the context of the first build error and the hint; andmodify the one of the plurality of files having the first build error with the first repair.17.The hardware storage device of claim 16, having stored thereon computer executable instructions that are structured to be executable by a processor of a computing device to thereby cause the computing device to perform further actions that:cause the language model to determine a next action to continue the migration;obtain from the language model a third action for the reviewer agent to build the project with the first repair and to verify that the first repair in the one of the plurality of files compiled successfully.18.The hardware storage device of claim 17, having stored thereon computer executable instructions that are structured to be executable by a processor of a computing device to thereby cause the computing device to perform further actions that:determine from the reviewer agent, that the compilation of the first repair causes a second build error; andcause the language model to determine a fourth action to fix the second build error.19.The hardware storage device of claim 18, having stored thereon computer executable instructions that are structured to be executable by a processor of a computing device to thereby cause the computing device to perform further actions that:obtain from the language model the fourth action indicating that the developer agent is to generate a second repair for the second build error; andcause, by the developer agent, the language model to generate the second repair for the second build error.20.The hardware storage device of claim 19, having stored thereon computer executable instructions that are structured to be executable by a processor of a computing device to thereby cause the computing device to perform further actions that:obtain, by the developer agent, the second repair;output, by the developer agent, the second repair to a user; andupon user acceptance of the second repair, modify, by the developer agent, the one of the plurality of files having the build error with the second repair.

Images