<p align="center">

<a href="docs/README_CN.md"><img src="docs/files/%E6%96%87%E6%A1%A3-%E4%B8%AD%E6%96%87%E7%89%88-blue.svg" alt="CN doc"></a>

<a href="README.md"><img src="docs/files/document-English-blue.svg" alt="EN doc"></a>

<a href="http://www.kuafuai.net"><img src="docs/files/%E5%AE%98%E7%BD%91-%E4%BC%81%E4%B8%9A%E7%89%88-purple.svg" alt="EN doc"></a>

<a href="docs/files/WeChat.jpg"><img src="docs/files/WeChat-%E5%BE%AE%E4%BF%A1-green.svg" alt="roadmap"></a>

</p>

<hr/>

Welcome to the AI Driven Software Development Automation Solution, abbreviated as DevOpsGPT. We combine LLM (Large Language Model) with DevOps tools to convert natural language requirements into functional software. This innovative feature greatly improves development efficiency, shortens development cycles, and reduces communication costs, resulting in higher-quality software delivery.

- Improved development efficiency: No need for tedious requirement document writing and explanations. Users can interact directly with DevOpsGPT to quickly convert requirements into functional software.

- Shortened development cycles: The automated software development process significantly reduces delivery time, accelerating software deployment and iterations.

- Reduced communication costs: By accurately understanding user requirements, DevOpsGPT minimizes the risk of communication errors and misunderstandings, enhancing collaboration efficiency between development and business teams.

- High-quality deliverables: DevOpsGPT generates code and performs validation, ensuring the quality and reliability of the delivered software.

- [Enterprise Edition] Existing project analysis: Through AI, automatic analysis of existing project information, accurate decomposition and development of required tasks on the basis of existing projects.

- [Enterprise Edition] Professional model selection: Support language model services stronger than GPT in the professional field to better complete requirements development tasks, and support private deployment.

- [Enterprise Edition] Support more DevOps platforms: can connect with more DevOps platforms to achieve the development and deployment of the whole process.

[{:height="40%" width="40%"}](https://www.youtube.com/watch?v=IWUPbGrJQOU)

- Clarify requirement documents: Interact with DevOpsGPT to clarify and confirm details in requirement documents.

- Generate interface documentation: DevOpsGPT can generate interface documentation based on the requirements, facilitating interface design and implementation for developers.

- Write pseudocode based on existing projects: Analyze existing projects to generate corresponding pseudocode, providing developers with references and starting points.

- Refine and optimize code functionality: Developers improve and optimize functionality based on the generated code.

- Continuous integration: Utilize DevOps tools for continuous integration to automate code integration and testing.

- Software version release: Deploy software versions to the target environment using DevOpsGPT and DevOps tools.

1. Clone the latest code or select a released version.

2. Generate the configuration file: Copy `env.yaml.tpl` and rename it to `env.yaml`.

3. Modify the configuration file: Edit `env.yaml` and add the necessary information such as GPT Token (refer to [documentation link](docs/DOCUMENT.md) for detailed instructions).

4. Run the service: Execute `sh run.sh` on Linux or Mac, or double-click `run.bat` on Windows.

5. Access the service: Access the service through a browser (check the startup log for the access address, default is http://127.0.0.1:8080).

6. Complete requirement development: Follow the instructions on the page to complete requirement development, and view the generated code in the `./workspace` directory.

For detailed documentation and configuration parameters, please refer to the [documentation link](docs/DOCUMENT.md).

Although we strive to enhance enterprise-level software development efficiency and reduce barriers with the help of large-scale language models, there are still some limitations in the current version:

- The generation of requirement and interface documentation may not be precise enough and might not meet developer intent in complex scenarios.

- In the current version, automating the understanding of existing project code is not possible. We are exploring a new solution that has shown promising results during validation and will be introduced in a future version.

- Accurate requirement decomposition and development task breakdown based on existing projects.

- New product experiences for rapid import of development requirements and parallel automation of software development and deployment.

- Introduce more software engineering tools and professional tools to quickly complete various software development tasks under AI planning and exectuion.

We invite you to participate in the DevOpsGPT project and contribute to the automation and innovation of software development, creating smarter and more efficient software systems!

This project, DevOpsGPT, is an experimental application and is provided "as-is" without any warranty, express or implied. By using this software, you agree to assume all risks associated with its use, including but not limited to data loss, system failure, or any other issues that may arise.

The developers and contributors of this project do not accept any responsibility or liability for any losses, damages, or other consequences that may occur as a result of using this software. You are solely responsible for any decisions and actions taken based on the information provided by DevOpsGPT.

Please note that the use of the GPT language model can be expensive due to its token usage. By utilizing this project, you acknowledge that you are responsible for monitoring and managing your own token usage and the associated costs. It is highly recommended to check your OpenAI API usage regularly and set up any necessary limits or alerts to prevent unexpected charges.

As an autonomous experiment, DevOpsGPT may generate content or take actions that are not in line with real-world business practices or legal requirements. It is your responsibility to ensure that any actions or decisions made based on the output of this software comply with all applicable laws, regulations, and ethical standards. The developers and contributors of this project shall not be held responsible for any consequences arising from the use of this software.

By using DevOpsGPT, you agree to indemnify, defend, and hold harmless the developers, contributors, and any affiliated parties from and against any and all claims, damages, losses, liabilities, costs, and expenses (including reasonable attorneys' fees) arising from your use of this software or your violation of these terms.

- https://github.com/Significant-Gravitas/Auto-GPT

- https://github.com/AntonOsika/gpt-engineer

- https://github.com/hwchase17/langchain

from .user import bp as user_bp

from .task import bp as task_bp

from .workspace import bp as workspace_bp

from .app import bp as app_bp

from .step_devops import bp as step_devops_bp

from .step_subtask import bp as step_subtask_bp

from .step_code import bp as step_code_bp

from .step_api import bp as step_api_bp

from .step_requirement import bp as step_requirement_bp

def register_controllers(app):

app.register_blueprint(user_bp)

app.register_blueprint(task_bp)

app.register_blueprint(workspace_bp)

app.register_blueprint(app_bp)

app.register_blueprint(step_requirement_bp)

app.register_blueprint(step_api_bp)

app.register_blueprint(step_subtask_bp)

app.register_blueprint(step_code_bp)

app.register_blueprint(step_devops_bp)

from flask import request, session

from app.controllers.common import json_response

from flask import Blueprint

from app.models.app import App

from app.extensions import db

from app.models.app_pro import AppPro

from app.pkgs.tools.i18b import getI18n

from config import GRADE

bp = Blueprint('app', __name__, url_prefix='/app')

def add():

_ = getI18n("controllers")

name = request.json.get('name')

intro = request.json.get('intro')

default_source_branch = request.json.get('default_source_branch')

default_target_branch = request.json.get('default_target_branch')

api_doc_url = request.json.get('api_doc_url')

owner = session['username']

app = App(owner=owner, name=name, default_source_branch=default_source_branch,

intro=intro, default_target_branch=default_target_branch, api_doc_url=api_doc_url)

try:

db.session.add(app)

db.session.commit()

return {'success': True}

except Exception as e:

raise Exception(_("Failed to add an application."))

def getAll():

_ = getI18n("controllers")

owner = session['username']

try:

if GRADE == "base":

apps = App.getAll(owner)

else:

apps = AppPro.getAll(owner)

return {'apps': apps}

except Exception as e:

raise Exception(_("Failed to get applications."))

from functools import wraps

import traceback

from flask import jsonify

def json_response(func):

@wraps(func) # Preserve the original function's name and docstring

def decorated_function(*args, **kwargs):

try:

result = func(*args, **kwargs)

response = {

'success': True,

'data': result

}

except Exception as e:

response = {

'success': False,

'error': str(e)

}

traceback.print_exc()

return jsonify(response)

return decorated_function

from flask import request, session

from app.controllers.common import json_response

from flask import Blueprint

from app.pkgs.prompt.api import clarifyAPI

from app.pkgs.prompt.api_pro import clarifyAPIPro

from app.pkgs.tools.i18b import getI18n

from config import GRADE

bp = Blueprint('step_api', __name__, url_prefix='/step_api')

def gen_interface_doc():

_ = getI18n("controllers")

user_prompt = request.json.get('user_prompt')

username = session["username"]

apiDocUrl = session[username]['memory']['appconfig']['apiDocUrl']

if GRADE == "base":

msg, success = clarifyAPI(user_prompt, apiDocUrl)

else:

msg, success = clarifyAPIPro(user_prompt, apiDocUrl)

session[username]['memory']['originalPrompt'] = user_prompt

session.update()

if success:

return {'message': msg}

else:

raise Exception(_("Failed to clarify API."))

from flask import request, session

import json

import re

from app.controllers.common import json_response

from app.pkgs.prompt.code import aiReferenceRepair

from app.pkgs.tools.i18b import getI18n

from config import GRADE

from app.pkgs.prompt.code import aiGenCode, aiMergeCode, aiCheckCode, aiFixError

from app.pkgs.devops.devops import get_file_content

from flask import Blueprint

bp = Blueprint('step_code', __name__, url_prefix='/step_code')

def edit_file_task():

_ = getI18n("controllers")

newTask = request.json.get('new_task')

newCode = request.json.get('new_code')

fileTask = request.json.get('file_task')

userName = session["username"]

appName = session[userName]['memory']['appconfig']['appName']

re, success = aiGenCode(fileTask, newTask, appName, newCode)

if not success:

raise Exception(_("Failed to edit file with new task."))

return {'success': success, 'code': re["code"], 'reasoning': re["reasoning"]}

def check_file():

_ = getI18n("controllers")

code = request.json.get('code')

fileTask = request.json.get('fileTask')

re, success = aiCheckCode(fileTask, code)

if not success:

raise Exception(_("Failed to check file."))

return {'success': success, 'code': re["code"], 'reasoning': re["reasoning"]}

def merge_file():

_ = getI18n("controllers")

baseCode = request.json.get('base_code')

newCode = request.json.get('new_code')

fileTask = request.json.get('file_task')

userName = session["username"]

appName = session[userName]['memory']['appconfig']['appName']

re, success = aiMergeCode(fileTask, appName, baseCode, newCode)

if not success:

raise Exception(_("Failed to merge old and new code."))

return {'success': success, 'code': re["code"], 'reasoning': re["reasoning"]}

def reference_repair():

_ = getI18n("controllers")

fileTask = request.json.get('file_task')

newCode = request.json.get('new_code')

referenceFile = request.json.get('reference_file')

repo = request.json.get('repo')

userName = session["username"]

appName = session[userName]['memory']['appconfig']['appName']

branch = session[userName]['memory']['appconfig']['sourceBranch']

hasGitCode, referenceCode = get_file_content(referenceFile, branch, repo)

if not hasGitCode:

raise Exception(_("Failed to reference repair no reference file found."))

re, success = aiReferenceRepair(newCode, appName, referenceCode, fileTask)

if not success:

raise Exception(_("Reference repair failed for unknown reasons."))

return {'success': success, 'code': re["code"], 'reasoning': re["reasoning"]}

def fix_compile():

code = request.json.get('code')

solution = request.json.get('solution')

re, success = aiFixError(solution, code)

reCode = re["code"]

reason = re["reasoning"]

return {'success': success, 'code': reCode, 'reasoning': reason}

def fix_lint():

code = request.json.get('code')

solution = request.json.get('solution')

re, success = aiFixError(solution, code)

reCode = re["code"]

reason = re["reasoning"]

return {'success': success, 'code': reCode, 'reasoning': reason}