Upload 9 files

ai.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import logging
+
+import openai
+
+logger = logging.getLogger(__name__)
+
+
+class AI:
+    def __init__(self, model="gpt-4", temperature=0.1):
+        self.temperature = temperature
+
+        try:
+            openai.Model.retrieve(model)
+            self.model = model
+        except openai.InvalidRequestError:
+            print(
+                f"Model {model} not available for provided API key. Reverting "
+                "to gpt-3.5-turbo. Sign up for the GPT-4 wait list here: "
+                "https://openai.com/waitlist/gpt-4-api"
+            )
+            self.model = "gpt-3.5-turbo"
+
+    def start(self, system, user):
+        messages = [
+            {"role": "system", "content": system},
+            {"role": "user", "content": user},
+        ]
+
+        return self.next(messages)
+
+    def fsystem(self, msg):
+        return {"role": "system", "content": msg}
+
+    def fuser(self, msg):
+        return {"role": "user", "content": msg}
+
+    def fassistant(self, msg):
+        return {"role": "assistant", "content": msg}
+
+    def next(self, messages: list[dict[str, str]], prompt=None):
+        if prompt:
+            messages += [{"role": "user", "content": prompt}]
+
+        logger.debug(f"Creating a new chat completion: {messages}")
+        response = openai.ChatCompletion.create(
+            messages=messages,
+            stream=True,
+            model=self.model,
+            temperature=self.temperature,
+        )
+
+        chat = []
+        for chunk in response:
+            delta = chunk["choices"][0]["delta"]
+            msg = delta.get("content", "")
+            print(msg, end="")
+            chat.append(msg)
+        print()
+        messages += [{"role": "assistant", "content": "".join(chat)}]
+        logger.debug(f"Chat completion finished: {messages}")
+        return messages

chat_to_files.py

@@ -0,0 +1,42 @@
+import re
+
+
+def parse_chat(chat):  # -> List[Tuple[str, str]]:
+    # Get all ``` blocks and preceding filenames
+    regex = r"(\S+)\n\s*```[^\n]*\n(.+?)```"
+    matches = re.finditer(regex, chat, re.DOTALL)
+
+    files = []
+    for match in matches:
+        # Strip the filename of any non-allowed characters and convert / to \
+        path = re.sub(r'[<>"|?*]', "", match.group(1))
+
+        # Remove leading and trailing brackets
+        path = re.sub(r"^\[(.*)\]$", r"\1", path)
+
+        # Remove leading and trailing backticks
+        path = re.sub(r"^`(.*)`$", r"\1", path)
+
+        # Remove trailing ]
+        path = re.sub(r"\]$", "", path)
+
+        # Get the code
+        code = match.group(2)
+
+        # Add the file to the list
+        files.append((path, code))
+
+    # Get all the text before the first ``` block
+    readme = chat.split("```")[0]
+    files.append(("README.md", readme))
+
+    # Return the files
+    return files
+
+
+def to_files(chat, workspace):
+    workspace["all_output.txt"] = chat
+
+    files = parse_chat(chat)
+    for file_name, file_content in files:
+        workspace[file_name] = file_content

ci.yaml

@@ -0,0 +1,32 @@
+name: Pytest Execution
+on:
+  pull_request:
+    branches:
+      - main
+  push:
+    branches:
+      - main
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version:
+          - "3.10"
+    steps:
+      - uses: actions/checkout@v3
+
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: pip
+
+      - name: Install package
+        run: pip install -e .
+
+      - name: Install test runner
+        run: pip install pytest pytest-cov
+
+      - name: Run unit tests
+        run: pytest --cov=gpt_engineer

db.py

@@ -0,0 +1,43 @@
+from dataclasses import dataclass
+from pathlib import Path
+
+
+# This class represents a simple database that stores its data as files in a directory.
+class DB:
+    """A simple key-value store, where keys are filenames and values are file contents."""
+
+    def __init__(self, path):
+        self.path = Path(path).absolute()
+
+        self.path.mkdir(parents=True, exist_ok=True)
+
+    def __contains__(self, key):
+        return (self.path / key).is_file()
+
+    def __getitem__(self, key):
+        full_path = self.path / key
+
+        if not full_path.is_file():
+            raise KeyError(key)
+        with full_path.open("r", encoding="utf-8") as f:
+            return f.read()
+
+    def __setitem__(self, key, val):
+        full_path = self.path / key
+        full_path.parent.mkdir(parents=True, exist_ok=True)
+
+        if isinstance(val, str):
+            full_path.write_text(val, encoding="utf-8")
+        else:
+            # If val is neither a string nor bytes, raise an error.
+            raise TypeError("val must be either a str or bytes")
+
+
+# dataclass for all dbs:
+@dataclass
+class DBs:
+    memory: DB
+    logs: DB
+    preprompts: DB
+    input: DB
+    workspace: DB

main.py

@@ -0,0 +1,65 @@
+import json
+import logging
+import shutil
+
+from pathlib import Path
+
+import typer
+
+from gpt_engineer import steps
+from gpt_engineer.ai import AI
+from gpt_engineer.db import DB, DBs
+from gpt_engineer.steps import STEPS
+
+app = typer.Typer()
+
+
+@app.command()
+def main(
+    project_path: str = typer.Argument("example", help="path"),
+    delete_existing: bool = typer.Argument(False, help="delete existing files"),
+    model: str = "gpt-4",
+    temperature: float = 0.1,
+    steps_config: steps.Config = typer.Option(
+        steps.Config.DEFAULT, "--steps", "-s", help="decide which steps to run"
+    ),
+    verbose: bool = typer.Option(False, "--verbose", "-v"),
+    run_prefix: str = typer.Option(
+        "",
+        help=(
+            "run prefix, if you want to run multiple variants of the same project and "
+            "later compare them"
+        ),
+    ),
+):
+    logging.basicConfig(level=logging.DEBUG if verbose else logging.INFO)
+
+    input_path = Path(project_path).absolute()
+    memory_path = input_path / f"{run_prefix}memory"
+    workspace_path = input_path / f"{run_prefix}workspace"
+
+    if delete_existing:
+        # Delete files and subdirectories in paths
+        shutil.rmtree(memory_path, ignore_errors=True)
+        shutil.rmtree(workspace_path, ignore_errors=True)
+
+    ai = AI(
+        model=model,
+        temperature=temperature,
+    )
+
+    dbs = DBs(
+        memory=DB(memory_path),
+        logs=DB(memory_path / "logs"),
+        input=DB(input_path),
+        workspace=DB(workspace_path),
+        preprompts=DB(Path(__file__).parent / "preprompts"),
+    )
+
+    for step in STEPS[steps_config]:
+        messages = step(ai, dbs)
+        dbs.logs[step.__name__] = json.dumps(messages)
+
+
+if __name__ == "__main__":
+    app()

pre-commit.yaml

@@ -0,0 +1,14 @@
+name: pre-commit
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+
+jobs:
+  pre-commit:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+    - uses: actions/setup-python@v4
+    - uses: pre-commit/action@v3.0.0

release.yaml

@@ -0,0 +1,52 @@
+name: Build and publish Python packages to PyPI
+
+on:
+  workflow_dispatch:
+  release:
+    types:
+      - published
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version:
+          - "3.10"
+    steps:
+      - uses: actions/checkout@v3
+
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: pip
+
+      - name: Install build tool
+        run: pip install build
+
+      - name: Build package
+        run: python -m build
+
+      - name: Upload package as build artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: package
+          path: dist/
+
+  publish:
+    runs-on: ubuntu-latest
+    needs: build
+    environment:
+      name: pypi
+      url: https://pypi.org/p/gpt-engineer
+    permissions:
+      id-token: write
+    steps:
+      - name: Collect packages to release
+        uses: actions/download-artifact@v3
+        with:
+          name: package
+          path: dist/
+
+      - name: Publish packages to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

steps.py

@@ -0,0 +1,278 @@
+import json
+import re
+import subprocess
+
+from enum import Enum
+from typing import Callable, TypeVar
+
+from gpt_engineer.ai import AI
+from gpt_engineer.chat_to_files import to_files
+from gpt_engineer.db import DBs
+
+
+def setup_sys_prompt(dbs):
+    return (
+        dbs.preprompts["generate"] + "\nUseful to know:\n" + dbs.preprompts["philosophy"]
+    )
+
+
+Step = TypeVar("Step", bound=Callable[[AI, DBs], list[dict]])
+
+
+def simple_gen(ai: AI, dbs: DBs):
+    """Run the AI on the main prompt and save the results"""
+    messages = ai.start(
+        setup_sys_prompt(dbs),
+        dbs.input["main_prompt"],
+    )
+    to_files(messages[-1]["content"], dbs.workspace)
+    return messages
+
+
+def clarify(ai: AI, dbs: DBs):
+    """
+    Ask the user if they want to clarify anything and save the results to the workspace
+    """
+    messages = [ai.fsystem(dbs.preprompts["qa"])]
+    user = dbs.input["main_prompt"]
+    while True:
+        messages = ai.next(messages, user)
+
+        if messages[-1]["content"].strip().lower().startswith("no"):
+            break
+
+        print()
+        user = input('(answer in text, or "c" to move on)\n')
+        print()
+
+        if not user or user == "c":
+            break
+
+        user += (
+            "\n\n"
+            "Is anything else unclear? If yes, only answer in the form:\n"
+            "{remaining unclear areas} remaining questions.\n"
+            "{Next question}\n"
+            'If everything is sufficiently clear, only answer "no".'
+        )
+
+    print()
+    return messages
+
+
+def gen_spec(ai: AI, dbs: DBs):
+    """
+    Generate a spec from the main prompt + clarifications and save the results to
+    the workspace
+    """
+    messages = [
+        ai.fsystem(setup_sys_prompt(dbs)),
+        ai.fsystem(f"Instructions: {dbs.input['main_prompt']}"),
+    ]
+
+    messages = ai.next(messages, dbs.preprompts["spec"])
+
+    dbs.memory["specification"] = messages[-1]["content"]
+
+    return messages
+
+
+def respec(ai: AI, dbs: DBs):
+    messages = json.loads(dbs.logs[gen_spec.__name__])
+    messages += [ai.fsystem(dbs.preprompts["respec"])]
+
+    messages = ai.next(messages)
+    messages = ai.next(
+        messages,
+        (
+            "Based on the conversation so far, please reiterate the specification for "
+            "the program. "
+            "If there are things that can be improved, please incorporate the "
+            "improvements. "
+            "If you are satisfied with the specification, just write out the "
+            "specification word by word again."
+        ),
+    )
+
+    dbs.memory["specification"] = messages[-1]["content"]
+    return messages
+
+
+def gen_unit_tests(ai: AI, dbs: DBs):
+    """
+    Generate unit tests based on the specification, that should work.
+    """
+    messages = [
+        ai.fsystem(setup_sys_prompt(dbs)),
+        ai.fuser(f"Instructions: {dbs.input['main_prompt']}"),
+        ai.fuser(f"Specification:\n\n{dbs.memory['specification']}"),
+    ]
+
+    messages = ai.next(messages, dbs.preprompts["unit_tests"])
+
+    dbs.memory["unit_tests"] = messages[-1]["content"]
+    to_files(dbs.memory["unit_tests"], dbs.workspace)
+
+    return messages
+
+
+def gen_clarified_code(ai: AI, dbs: DBs):
+    # get the messages from previous step
+
+    messages = json.loads(dbs.logs[clarify.__name__])
+
+    messages = [
+        ai.fsystem(setup_sys_prompt(dbs)),
+    ] + messages[1:]
+    messages = ai.next(messages, dbs.preprompts["use_qa"])
+
+    to_files(messages[-1]["content"], dbs.workspace)
+    return messages
+
+
+def gen_code(ai: AI, dbs: DBs):
+    # get the messages from previous step
+
+    messages = [
+        ai.fsystem(setup_sys_prompt(dbs)),
+        ai.fuser(f"Instructions: {dbs.input['main_prompt']}"),
+        ai.fuser(f"Specification:\n\n{dbs.memory['specification']}"),
+        ai.fuser(f"Unit tests:\n\n{dbs.memory['unit_tests']}"),
+    ]
+    messages = ai.next(messages, dbs.preprompts["use_qa"])
+    to_files(messages[-1]["content"], dbs.workspace)
+    return messages
+
+
+def execute_entrypoint(ai, dbs):
+    command = dbs.workspace["run.sh"]
+
+    print("Do you want to execute this code?")
+    print()
+    print(command)
+    print()
+    print('If yes, press enter. Otherwise, type "no"')
+    print()
+    if input() not in ["", "y", "yes"]:
+        print("Ok, not executing the code.")
+        return []
+    print("Executing the code...")
+    print(
+        "\033[92m"  # green color
+        + "Note: If it does not work as expected, please consider running the code'"
+        + " in another way than above."
+        + "\033[0m"
+    )
+    print()
+    subprocess.run("bash run.sh", shell=True, cwd=dbs.workspace.path)
+    return []
+
+
+def gen_entrypoint(ai, dbs):
+    messages = ai.start(
+        system=(
+            "You will get information about a codebase that is currently on disk in "
+            "the current folder.\n"
+            "From this you will answer with code blocks that includes all the necessary "
+            "unix terminal commands to "
+            "a) install dependencies "
+            "b) run all necessary parts of the codebase (in parallell if necessary).\n"
+            "Do not install globally. Do not use sudo.\n"
+            "Do not explain the code, just give the commands.\n"
+            "Do not use placeholders, use example values (like . for a folder argument) "
+            "if necessary.\n"
+        ),
+        user="Information about the codebase:\n\n" + dbs.workspace["all_output.txt"],
+    )
+    print()
+
+    regex = r"```\S*\n(.+?)```"
+    matches = re.finditer(regex, messages[-1]["content"], re.DOTALL)
+    dbs.workspace["run.sh"] = "\n".join(match.group(1) for match in matches)
+    return messages
+
+
+def use_feedback(ai: AI, dbs: DBs):
+    messages = [
+        ai.fsystem(setup_sys_prompt(dbs)),
+        ai.fuser(f"Instructions: {dbs.input['main_prompt']}"),
+        ai.fassistant(dbs.workspace["all_output.txt"]),
+        ai.fsystem(dbs.preprompts["use_feedback"]),
+    ]
+    messages = ai.next(messages, dbs.input["feedback"])
+    to_files(messages[-1]["content"], dbs.workspace)
+    return messages
+
+
+def fix_code(ai: AI, dbs: DBs):
+    code_output = json.loads(dbs.logs[gen_code.__name__])[-1]["content"]
+    messages = [
+        ai.fsystem(setup_sys_prompt(dbs)),
+        ai.fuser(f"Instructions: {dbs.input['main_prompt']}"),
+        ai.fuser(code_output),
+        ai.fsystem(dbs.preprompts["fix_code"]),
+    ]
+    messages = ai.next(messages, "Please fix any errors in the code above.")
+    to_files(messages[-1]["content"], dbs.workspace)
+    return messages
+
+
+class Config(str, Enum):
+    DEFAULT = "default"
+    BENCHMARK = "benchmark"
+    SIMPLE = "simple"
+    TDD = "tdd"
+    TDD_PLUS = "tdd+"
+    CLARIFY = "clarify"
+    RESPEC = "respec"
+    EXECUTE_ONLY = "execute_only"
+    USE_FEEDBACK = "use_feedback"
+
+
+# Different configs of what steps to run
+STEPS = {
+    Config.DEFAULT: [
+        clarify,
+        gen_clarified_code,
+        gen_entrypoint,
+        execute_entrypoint,
+    ],
+    Config.BENCHMARK: [simple_gen, gen_entrypoint],
+    Config.SIMPLE: [simple_gen, gen_entrypoint, execute_entrypoint],
+    Config.TDD: [
+        gen_spec,
+        gen_unit_tests,
+        gen_code,
+        gen_entrypoint,
+        execute_entrypoint,
+    ],
+    Config.TDD_PLUS: [
+        gen_spec,
+        gen_unit_tests,
+        gen_code,
+        fix_code,
+        gen_entrypoint,
+        execute_entrypoint,
+    ],
+    Config.CLARIFY: [
+        clarify,
+        gen_clarified_code,
+        gen_entrypoint,
+        execute_entrypoint,
+    ],
+    Config.RESPEC: [
+        gen_spec,
+        respec,
+        gen_unit_tests,
+        gen_code,
+        fix_code,
+        gen_entrypoint,
+        execute_entrypoint,
+    ],
+    Config.USE_FEEDBACK: [use_feedback, gen_entrypoint, execute_entrypoint],
+    Config.EXECUTE_ONLY: [gen_entrypoint, execute_entrypoint],
+}
+
+# Future steps that can be added:
+# run_tests_and_fix_files
+# execute_entrypoint_and_fix_files_if_needed