gibson-cli 0.1.0__py3-none-any.whl

command/OpenApi.py

@@ -0,0 +1,141 @@
+import json
+import re
+import sys
+
+from api.Cli import Cli
+
+from .BaseCommand import BaseCommand
+
+
+class OpenApi(BaseCommand):
+    def bad_json(self):
+        self.conversation.display_project(self.configuration.project.name)
+        self.conversation.type(
+            "I need valid JSON. That file does not appear to be that. Try again?\n"
+        )
+        self.conversation.newline()
+        exit(1)
+
+    def execute(self):
+        if len(sys.argv) != 3:
+            self.usage()
+
+        try:
+            with open(sys.argv[2], "r") as f:
+                contents = json.loads(f.read())
+        except FileNotFoundError:
+            self.file_not_found()
+        except json.decoder.JSONDecodeError:
+            self.bad_json()
+
+        if "paths" not in contents:
+            self.unrecognized_format()
+
+        self.conversation.display_project(self.configuration.project.name)
+
+        if contents.get("info", None) is not None:
+            if contents["info"].get("title", None) is not None:
+                self.conversation.type(contents["info"]["title"])
+                self.conversation.newline()
+
+        path_list = []
+        for path, description in contents["paths"].items():
+            path_list.append(path)
+
+        path_list.sort()
+
+        i = 0
+        for path in path_list:
+            self.conversation.type(f"   {i}: ".rjust(10) + path + "\n", delay=0.0009)
+            i += 1
+
+        self.conversation.newline()
+
+        self.conversation.type(
+            "Now tell me which ones you want me to build for you. You can provide a "
+            + 'single\nnumber, a comma separated list of numbers or "all" to build '
+            + "everything.\n"
+        )
+        self.conversation.newline()
+
+        selection = ""
+        while len(selection) == 0:
+            selection = input("What should I build? ")
+
+        selection_list = re.sub(" ", "", selection.lower()).split(",")
+
+        choices = []
+        if "all" in selection_list:
+            choices = path_list
+        else:
+            for choice in selection_list:
+                try:
+                    choices.append(path_list[int(choice)])
+                except (IndexError, ValueError):
+                    pass
+
+        self.conversation.newline()
+
+        if len(choices) == 0:
+            exit(1)
+
+        cli = Cli(self.configuration)
+        self.conversation.type("Building schema...\n")
+
+        entities = []
+        for choice in choices:
+            self.conversation.type("    " + choice + "\n")
+
+            response = cli.modeler_openapi(
+                self.configuration.project.modeler.version,
+                json.dumps(contents["paths"][choice]),
+            )
+
+            for entity in response["entities"]:
+                entities.append(entity)
+                self.conversation.type(" " * 8 + entity["name"])
+                self.conversation.newline()
+
+        self.conversation.type("Reconciling schema...\n")
+        response = cli.modeler_reconcile(
+            self.configuration.project.modeler.version, entities
+        )
+
+        self.memory.remember_last(response)
+
+        word_entities = "entities"
+        if len(response["entities"]) == 1:
+            word_entities = "entity"
+
+        self.conversation.type("\nSummary\n")
+        self.conversation.type(
+            f"    {len(response['entities'])} {word_entities} imported\n"
+        )
+        self.conversation.newline()
+
+        return True
+
+    def file_not_found(self):
+        self.conversation.display_project(self.configuration.project.name)
+        self.conversation.type(
+            f'Well that embarrassing. There is no file "{sys.argv[2]}".\n'
+        )
+        self.conversation.newline()
+        exit(1)
+
+    def unrecognized_format(self):
+        self.conversation.display_project(self.configuration.project.name)
+        self.conversation.type(
+            "Well that sucks. I do not recognize this JSON format.\n"
+        )
+        self.conversation.newline()
+        exit(1)
+
+    def usage(self):
+        self.conversation.display_project(self.configuration.project.name)
+        self.conversation.type(
+            f"usage: {self.configuration.command} openapi [file path]"
+            + "\n  where [file path] is the full path to an OpenAPI spec\n"
+        )
+        self.conversation.newline()
+        exit(1)

command/Question.py

@@ -0,0 +1,105 @@
+import os
+import sys
+
+from api.Cli import Cli
+
+from .BaseCommand import BaseCommand
+
+
+class Question(BaseCommand):
+    TOKEN_FILE = "file://"
+    TOKEN_PYTHON = "py://"
+    TOKEN_SQL = "sql://"
+
+    def execute(self):
+        if len(sys.argv) < 3:
+            self.usage()
+
+        instructions = ""
+        has_file = False
+        has_python = False
+        has_sql = False
+        for term in sys.argv[2:]:
+            if self.TOKEN_FILE in term:
+                token, path = term.split(self.TOKEN_FILE)
+
+                try:
+                    with open(path, "r") as f:
+                        contents = f.read()
+                except FileNotFoundError:
+                    self.__file_not_found(path)
+
+                has_file = True
+                instructions += f"\n\n{contents}\n\n"
+            elif self.TOKEN_PYTHON in term:
+                token, import_ = term.split(self.TOKEN_PYTHON)
+                import_ = import_.replace(".", "/")
+
+                contents = None
+                for path in os.environ["PYTHONPATH"].split(":"):
+                    try:
+                        with open(f"{path}/{import_}.py", "r") as f:
+                            contents = f.read()
+                    except FileNotFoundError:
+                        pass
+
+                if contents is None:
+                    self.__python_import_not_found(import_.replace("/", "."))
+
+                has_python = True
+                instructions += f"\n\n{contents}\n\n"
+            elif self.TOKEN_SQL in term:
+                token, name = term.split(self.TOKEN_SQL)
+
+                entity = self.memory.recall_entity(name)
+                if entity is None:
+                    self.conversation.not_sure_no_entity(
+                        self.configuration.project.name, name
+                    )
+                    exit(1)
+
+                has_sql = True
+                instructions += f"\n\n{entity['definition']}\n\n"
+            else:
+                instructions += f"{term} "
+
+        if instructions != "":
+            cli = Cli(self.configuration)
+            response = cli.llm_query(instructions, has_file, has_python, has_sql)
+
+        if response["entities"] is not None and len(response["entities"]) > 0:
+            self.memory.remember_last({"entities": response["entities"]})
+
+        self.conversation.raw_llm_response()
+        print(response["commentary"].rstrip())
+
+        if response["entities"] is not None and len(response["entities"]) > 0:
+            self.conversation.newline()
+            self.conversation.entities_hijacked()
+            self.conversation.newline()
+
+        self.conversation.newline()
+
+    def __file_not_found(self, path):
+        self.conversation.display_project(self.configuration.project.name)
+        self.conversation.type(f'404, My Friend. Cannot find file "{path}".\n')
+        self.conversation.newline()
+        exit(1)
+
+    def __python_import_not_found(self, import_):
+        self.conversation.display_project(self.configuration.project.name)
+        self.conversation.type(f'That\'s a misfire, "{import_}" does not exist.\n')
+        self.conversation.newline()
+        exit(1)
+
+    def usage(self):
+        self.conversation.display_project(self.configuration.project.name)
+        self.conversation.type(
+            f"usage: {self.configuration.command} ? [instructions]\n"
+            + "  where [instructions] is natural language\n"
+            + f"    use {self.TOKEN_FILE}[path] to import a file from the filesystem\n"
+            + f"    use {self.TOKEN_PYTHON}[import] to import a file from PYTHONPATH\n"
+            + f"    use {self.TOKEN_SQL}[entity name] to import the SQL\n"
+        )
+        self.conversation.newline()
+        exit(1)

command/Remove.py

@@ -0,0 +1,80 @@
+import sys
+
+from api.Cli import Cli
+
+from .BaseCommand import BaseCommand
+from .Rewrite import Rewrite
+
+
+class Remove(BaseCommand):
+    def execute(self):
+        if len(sys.argv) != 3:
+            self.usage()
+
+        self.conversation.display_project(self.configuration.project.name)
+
+        found = False
+
+        last = self.memory.recall_last()
+        if last is not None:
+            entities = []
+            for entity in last["entities"]:
+                if entity["name"] == sys.argv[2]:
+                    found = True
+                else:
+                    entities.append(entity)
+
+            if found:
+                if len(entities) == 0:
+                    self.memory.forget_last()
+                else:
+                    self.memory.remember_last({"entities": entities})
+
+                self.conversation.type(f"[Removed] {sys.argv[2]}\n")
+                self.conversation.newline()
+
+                return self
+
+        cli = Cli(self.configuration)
+        entities = []
+
+        stored = self.memory.recall_entities()
+        if stored is not None and len(stored) > 0:
+            for entity in stored:
+                entities.append(entity)
+                if entity["name"] == sys.argv[2]:
+                    found = True
+
+        if not found:
+            self.conversation.type(
+                f'Nothing removed, did not find entity named "{sys.argv[2]}".\n'
+            )
+            self.conversation.newline()
+            return self
+
+        response = cli.modeler_entity_remove(
+            self.configuration.project.modeler.version, entities, sys.argv[2]
+        )
+
+        if len(response["entities"]) == 0:
+            self.memory.forget_stored()
+        else:
+            self.memory.remember_entities(response["entities"])
+
+        self.conversation.type(f"[Removed] {sys.argv[2]}\n")
+        self.conversation.newline()
+
+        Rewrite(self.configuration, header="Refactoring").execute()
+
+        self.conversation.newline()
+
+        return self
+
+    def usage(self):
+        self.conversation.display_project(self.configuration.project.name)
+        self.conversation.type(
+            f"usage: {self.configuration.command} remove [entity name]\n"
+            + "  where [entity name] is one of the entities that exists in this project\n"
+        )
+        self.conversation.newline()
+        exit(1)

command/Rename.py

@@ -0,0 +1,71 @@
+import sys
+
+from api.Cli import Cli
+
+from .BaseCommand import BaseCommand
+from .Rewrite import Rewrite
+
+
+class Rename(BaseCommand):
+    def execute(self):
+        if len(sys.argv) != 4:
+            self.usage()
+
+        self.conversation.display_project(self.configuration.project.name)
+
+        if self.memory.recall_entity(sys.argv[2]) is None:
+            self.conversation.type(
+                f'Nothing renamed, did not find entity named "{sys.argv[2]}".\n'
+            )
+            self.conversation.newline()
+            return self
+
+        if self.memory.recall_entity(sys.argv[3]) is not None:
+            self.conversation.type(
+                f'Cannot rename to "{sys.argv[3]}" because that entity already exists.\n'
+            )
+            self.conversation.newline()
+            return self
+
+        cli = Cli(self.configuration)
+
+        last = self.memory.recall_last()
+        if last is not None:
+            response = cli.modeler_entity_rename(
+                self.configuration.project.modeler.version,
+                last["entities"],
+                sys.argv[2],
+                sys.argv[3],
+            )
+
+            self.memory.remember_last({"entities": response["entities"]})
+
+        stored = self.memory.recall_entities()
+        if stored is not None:
+            response = cli.modeler_entity_rename(
+                self.configuration.project.modeler.version,
+                stored,
+                sys.argv[2],
+                sys.argv[3],
+            )
+
+            self.memory.remember_entities(response["entities"])
+
+        self.conversation.type(f"[Renamed] {sys.argv[2]} -> {sys.argv[3]}\n")
+        self.conversation.newline()
+
+        Rewrite(self.configuration, header="Refactoring").execute()
+
+        self.conversation.newline()
+
+        return self
+
+    def usage(self):
+        self.conversation.display_project(self.configuration.project.name)
+        self.conversation.type(
+            f"usage: {self.configuration.command} rename [current] [new]\n"
+            + "  where [current] is the name of an entity and [new] is what "
+            + "you want to call it\n"
+        )
+        self.conversation.newline()
+        exit(1)

command/Rewrite.py

@@ -0,0 +1,107 @@
+import os
+import shutil
+
+from core.Configuration import Configuration
+from services.code.customization.CustomizationManager import CustomizationManager
+from core.TimeKeeper import TimeKeeper
+
+from .Api import Api
+from .Base import Base
+from .BaseCommand import BaseCommand
+from .Models import Models
+from .Schemas import Schemas
+from .Tests import Tests
+
+
+class Rewrite(BaseCommand):
+    def __init__(
+        self,
+        configuration: Configuration,
+        header="Writing Code",
+        wipe=True,
+        with_header=False,
+    ):
+        super().__init__(configuration)
+        self.wipe = wipe
+        self.with_header = with_header
+
+    def execute(self):
+        if self.with_header is True:
+            self.conversation.display_project(self.configuration.project.name)
+
+        customization_manager = CustomizationManager(self.configuration).preserve()
+
+        try:
+            if self.wipe is True:
+                for root, dirs, files in os.walk(
+                    os.path.expandvars(self.configuration.project.dev.base.path)
+                ):
+                    for file in files:
+                        os.unlink(os.path.join(root, file))
+
+                    for dir_ in dirs:
+                        shutil.rmtree(os.path.join(root, dir_))
+
+            self.conversation.type("Writing Code\n")
+
+            time_keeper = TimeKeeper()
+
+            self.conversation.type("  API      ")
+
+            self.conversation.mute()
+            Api(self.configuration).disable_customization_management().execute()
+            self.conversation.unmute()
+
+            self.conversation.type(time_keeper.get_display())
+            self.conversation.newline()
+
+            time_keeper = TimeKeeper()
+
+            self.conversation.type("  Base     ")
+
+            self.conversation.mute()
+            Base(self.configuration).execute()
+            self.conversation.unmute()
+
+            self.conversation.type(time_keeper.get_display())
+            self.conversation.newline()
+
+            time_keeper = TimeKeeper()
+
+            self.conversation.type("  Models   ")
+
+            self.conversation.mute()
+            Models(self.configuration).execute()
+            self.conversation.unmute()
+
+            self.conversation.type(time_keeper.get_display())
+            self.conversation.newline()
+
+            time_keeper = TimeKeeper()
+
+            self.conversation.type("  Schemas  ")
+
+            self.conversation.mute()
+            Schemas(self.configuration).execute()
+            self.conversation.unmute()
+
+            self.conversation.type(time_keeper.get_display())
+            self.conversation.newline()
+
+            time_keeper = TimeKeeper()
+
+            self.conversation.type("  Tests    ")
+
+            self.conversation.mute()
+            Tests(self.configuration).execute()
+            self.conversation.unmute()
+
+            self.conversation.type(time_keeper.get_display())
+            self.conversation.newline()
+        finally:
+            customization_manager.restore()
+
+        if self.with_header is True:
+            self.conversation.newline()
+
+        return self

command/Schema.py

@@ -0,0 +1,42 @@
+import sys
+
+from api.Cli import Cli
+from dev.Dev import Dev
+from core.TimeKeeper import TimeKeeper
+
+from .BaseCommand import BaseCommand
+
+
+class Schema(BaseCommand):
+    def execute(self):
+        if len(sys.argv) != 3:
+            self.usage()
+
+        entity = self.memory.recall_stored_entity(sys.argv[2])
+        if entity is None:
+            self.conversation.not_sure_no_entity(
+                self.configuration.project.name, sys.argv[2]
+            )
+            exit(1)
+
+        time_keeper = TimeKeeper()
+
+        cli = Cli(self.configuration)
+        response = cli.code_schemas([entity["name"]])
+
+        Dev(self.configuration).schema(
+            response["code"][0]["entity"]["name"], response["code"][0]["definition"]
+        )
+
+        print(response["code"][0]["definition"])
+        time_keeper.display()
+
+    def usage(self):
+        self.conversation.display_project(self.configuration.project.name)
+        self.conversation.type(
+            f"usage: {self.configuration.command} schema [entity name]\n"
+            + "  where [entity name] is one of the entities that exists in "
+            + "this project\n"
+        )
+        self.conversation.newline()
+        exit(1)

command/Schemas.py

@@ -0,0 +1,31 @@
+from api.Cli import Cli
+from dev.Dev import Dev
+from core.TimeKeeper import TimeKeeper
+
+from .BaseCommand import BaseCommand
+
+
+class Schemas(BaseCommand):
+    def execute(self):
+        entities = []
+        if self.memory.entities is not None:
+            for entity in self.memory.entities:
+                entities.append(entity["name"])
+
+        if len(entities) == 0:
+            self.conversation.cant_no_entities(self.configuration.project.name)
+            exit(1)
+
+        time_keeper = TimeKeeper()
+
+        cli = Cli(self.configuration)
+        response = cli.code_schemas(entities)
+
+        for entry in response["code"]:
+            Dev(self.configuration).schema(entry["entity"]["name"], entry["definition"])
+
+            if self.conversation.muted() is False:
+                print(entry["definition"])
+
+        if self.conversation.muted() is False:
+            time_keeper.display()

command/Show.py

@@ -0,0 +1,37 @@
+import sys
+
+from .BaseCommand import BaseCommand
+
+
+class Show(BaseCommand):
+    def execute(self):
+        if len(sys.argv) == 2:
+            entities = self.memory.recall_merged()
+            if entities is None:
+                self.conversation.cant_no_entities(self.configuration.project.name)
+                exit(1)
+        elif len(sys.argv) == 3:
+            entity = self.memory.recall_entity(sys.argv[2])
+            if entity is None:
+                self.conversation.not_sure_no_entity(
+                    self.configuration.project.name, sys.argv[2]
+                )
+                exit(1)
+
+            entities = [entity]
+        else:
+            self.usage()
+
+        for entity in entities:
+            print(entity["definition"])
+
+    def usage(self):
+        self.conversation.display_project(self.configuration.project.name)
+        self.conversation.type(
+            f"usage: {self.configuration.command} show {{entity name}}\n"
+            + "  where {entity name} is one of the entities that exists in "
+            + "this project\n"
+            + "  omitting {entity name} displays all entities\n"
+        )
+        self.conversation.newline()
+        exit(1)

command/Test.py

@@ -0,0 +1,42 @@
+import sys
+
+from api.Cli import Cli
+from dev.Dev import Dev
+from core.TimeKeeper import TimeKeeper
+
+from .BaseCommand import BaseCommand
+
+
+class Test(BaseCommand):
+    def execute(self):
+        if len(sys.argv) != 3:
+            self.usage()
+
+        entity = self.memory.recall_stored_entity(sys.argv[2])
+        if entity is None:
+            self.conversation.not_sure_no_entity(
+                self.configuration.project.name, sys.argv[2]
+            )
+            exit(1)
+
+        time_keeper = TimeKeeper()
+
+        cli = Cli(self.configuration)
+        response = cli.code_testing([entity["name"]])
+
+        Dev(self.configuration).tests(
+            response["code"][0]["entity"]["name"], response["code"][0]["definition"]
+        )
+
+        print(response["code"][0]["definition"])
+        time_keeper.display()
+
+    def usage(self):
+        self.conversation.display_project(self.configuration.project.name)
+        self.conversation.type(
+            f"usage: {self.configuration.command} test [entity name]\n"
+            + "  where [entity name] is one of the entities that exists "
+            + "in this project\n"
+        )
+        self.conversation.newline()
+        exit(1)

command/Tests.py

@@ -0,0 +1,31 @@
+from api.Cli import Cli
+from dev.Dev import Dev
+from core.TimeKeeper import TimeKeeper
+
+from .BaseCommand import BaseCommand
+
+
+class Tests(BaseCommand):
+    def execute(self):
+        entities = []
+        if self.memory.entities is not None:
+            for entity in self.memory.entities:
+                entities.append(entity["name"])
+
+        if len(entities) == 0:
+            self.conversation.cant_no_entities(self.configuration.project.name)
+            exit(1)
+
+        time_keeper = TimeKeeper()
+
+        cli = Cli(self.configuration)
+        response = cli.code_testing(entities)
+
+        for entry in response["code"]:
+            Dev(self.configuration).tests(entry["entity"]["name"], entry["definition"])
+
+            if self.conversation.muted() is False:
+                print(entry["definition"])
+
+        if self.conversation.muted() is False:
+            time_keeper.display()