gibson-cli 0.4.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

gibson/api/Cli.py

@@ -8,6 +8,10 @@ from .BaseApi import BaseApi
 class Cli(BaseApi):
     PREFIX = "cli"
 
+    def __init__(self, configuration: Configuration):
+        self.configuration = configuration
+        self.configuration.ensure_project()
+
     def code_api(self):
         return self.post(
             "code/api",
@@ -76,6 +80,7 @@ class Cli(BaseApi):
 
     def llm_query(self, instructions, has_file, has_python, has_sql):
         project_config = self.configuration.project
+
         r = self.post(
             "llm/query",
             {
@@ -86,6 +91,7 @@ class Cli(BaseApi):
                         "sql": int(has_sql),
                     }
                 },
+                "datastore": {"type": project_config.datastore.type},
                 "frameworks": {
                     "api": project_config.code.frameworks.api,
                     "model": project_config.code.frameworks.model,
@@ -105,6 +111,7 @@ class Cli(BaseApi):
         r = self.put(
             "modeler/entity/modify",
             {
+                "datastore": {"type": self.configuration.project.datastore.type},
                 "entity": entity,
                 "modeler": {"version": modeler_version},
                 "modifications": modifications,
@@ -118,6 +125,7 @@ class Cli(BaseApi):
         r = self.put(
             "modeler/entity/remove",
             {
+                "datastore": {"type": self.configuration.project.datastore.type},
                 "entity": {"name": entity_name},
                 "modeler": {"version": modeler_version},
                 "schema_": entities,
@@ -130,6 +138,7 @@ class Cli(BaseApi):
         r = self.put(
             "modeler/entity/rename",
             {
+                "datastore": {"type": self.configuration.project.datastore.type},
                 "entity": {"current": current, "new": new},
                 "modeler": {"version": modeler_version},
                 "schema_": entities,
@@ -142,6 +151,7 @@ class Cli(BaseApi):
         r = self.post(
             "modeler/module",
             {
+                "datastore": {"type": self.configuration.project.datastore.type},
                 "modeler": {"version": modeler_version},
                 "module": module,
                 "project": {"description": project_description},
@@ -161,7 +171,11 @@ class Cli(BaseApi):
     def modeler_reconcile(self, modeler_version, entities: list):
         r = self.post(
             "modeler/reconcile",
-            {"modeler": {"version": modeler_version}, "schema_": entities},
+            {
+                "datastore": {"type": self.configuration.project.datastore.type},
+                "modeler": {"version": modeler_version},
+                "schema_": entities,
+            },
         )
 
         return r.json()
@@ -173,11 +187,13 @@ class Cli(BaseApi):
         with_stored=False,
     ):
         project_config = self.configuration.project
+
         payload = {
             "api": {
                 "prefix": project_config.dev.api.prefix,
                 "version": project_config.dev.api.version,
             },
+            "datastore": {"type": project_config.datastore.type},
             "frameworks": {
                 "api": project_config.code.frameworks.api,
                 "model": project_config.code.frameworks.model,

gibson/command/Build.py

@@ -4,12 +4,13 @@ from sqlalchemy import create_engine
 from sqlalchemy.orm import sessionmaker
 
 from gibson.command.BaseCommand import BaseCommand
+from gibson.core.Colors import argument, command, hint, subcommand
 from gibson.db.TableExceptions import TableExceptions
 
 
 class Build(BaseCommand):
     def __build_datastore(self):
-        self.conversation.display_project(self.configuration.project.name)
+        self.configuration.display_project()
 
         db = create_engine(self.configuration.project.datastore.uri)
         session = sessionmaker(autocommit=False, autoflush=False, bind=db)()
@@ -48,13 +49,15 @@ class Build(BaseCommand):
         if len(sys.argv) != 3 or sys.argv[2] != "datastore":
             self.usage()
 
+        self.configuration.ensure_project()
+
         if self.memory.entities is None or len(self.memory.entities) == 0:
             self.no_entities()
 
         self.__build_datastore()
 
     def no_entities(self):
-        self.conversation.display_project(self.configuration.project.name)
+        self.configuration.display_project()
         self.conversation.type(
             "Ahhh man. I would love to but there aren't any entities.\n"
         )
@@ -62,7 +65,14 @@ class Build(BaseCommand):
         exit(1)
 
     def usage(self):
-        self.conversation.display_project(self.configuration.project.name)
-        self.conversation.type(f"usage: {self.configuration.command} build datastore\n")
+        self.configuration.display_project()
+        datastore_uri = (
+            self.configuration.project.datastore.uri
+            if self.configuration.project
+            else ""
+        )
+        self.conversation.type(
+            f"usage: {command(self.configuration.command)} {subcommand('build')} {argument('datastore')} {hint('build the datastore')} {datastore_uri}\n"
+        )
         self.conversation.newline()
         exit(1)

gibson/command/Code.py

@@ -7,6 +7,7 @@ from gibson.api.Cli import Cli
 from gibson.command.BaseCommand import BaseCommand
 from gibson.command.Merge import Merge
 from gibson.command.rewrite.Rewrite import Rewrite
+from gibson.core.Colors import argument, command, hint, input, subcommand
 from gibson.core.Configuration import Configuration
 from gibson.display.Header import Header
 from gibson.display.WorkspaceFooter import WorkspaceFooter
@@ -86,7 +87,8 @@ class Code(BaseCommand):
 
         cli = Cli(self.configuration)
 
-        self.conversation.display_project(self.configuration.project.name)
+        self.configuration.ensure_project()
+        self.configuration.display_project()
         definition = self.configure_definition()
 
         self.conversation.c64_boot_search()
@@ -184,16 +186,14 @@ class Code(BaseCommand):
         print(WorkspaceFooter().render())
 
     def usage(self):
-        self.conversation.display_project(self.configuration.project.name)
+        self.configuration.display_project()
         self.conversation.type(
-            f"usage: {self.configuration.command} code [thing] [name]\n"
-            + '  where [thing] can only be "entity", for now\n'
-            + "  and [name] is what you want [thing] to be called\n"
+            f"usage: {command(self.configuration.command)} {subcommand('code')} {argument('entity')} {input('[entity name]')} {hint('create a new entity')}\n"
         )
         self.conversation.newline()
         self.conversation.type(
-            '  To create a new entity called "user":\n'
-            "      gibson code entity user\n"
+            '  To create a new entity named "user":\n'
+            f"      {command(self.configuration.command)} {subcommand('code')} {argument('entity')} {input('user')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/Conf.py

@@ -1,6 +1,7 @@
 import sys
 
 from gibson.command.BaseCommand import BaseCommand
+from gibson.core.Colors import argument, command, hint, input, subcommand
 
 
 class Conf(BaseCommand):
@@ -38,7 +39,8 @@ class Conf(BaseCommand):
         except KeyError:
             self.usage()
 
-        self.conversation.display_project(self.configuration.project.name)
+        self.configuration.ensure_project()
+        self.configuration.display_project()
         self.conversation.type(f"{key}\n")
         self.conversation.type(f"  [old value] {old_value}\n")
         self.conversation.type(f"  [new value] {value}\n")
@@ -57,18 +59,19 @@ class Conf(BaseCommand):
         return configuration_keys
 
     def usage(self):
-        self.conversation.display_project(self.configuration.project.name)
+        self.configuration.display_project()
         self.conversation.type(
-            f"usage: {self.configuration.command} conf [key] [value]\n"
-            "  where [key] is one of:\n"
+            f"usage: {command(self.configuration.command)} {subcommand('conf')} {argument('[key]')} {input('[value]')} {hint('set a configuration value')}\n"
         )
-        self.conversation.set_delay(0.004)
+        self.conversation.newline()
 
-        for key in self.get_configuration_keys():
-            self.conversation.type(f"    {key}\n")
+        if self.configuration.project:
+            self.conversation.type(f"  where {argument('[key]')} is one of:\n")
+            self.conversation.set_delay(0.004)
+
+            for key in self.get_configuration_keys():
+                self.conversation.type(f"    {key}\n")
+
+            self.conversation.newline()
 
-        self.conversation.newline()
-        self.conversation.type('"That was recursive! I used recursion, guys!"\n')
-        self.conversation.type("                      -- Montero, 02/06/2024\n")
-        self.conversation.newline()
         exit(1)

gibson/command/Count.py

@@ -1,6 +1,7 @@
 import sys
 
-from .BaseCommand import BaseCommand
+from gibson.command.BaseCommand import BaseCommand
+from gibson.core.Colors import arguments, command, hint, subcommand
 
 
 class Count(BaseCommand):
@@ -8,6 +9,8 @@ class Count(BaseCommand):
         if len(sys.argv) != 3 or sys.argv[2] not in ["last", "stored"]:
             self.usage()
 
+        self.configuration.ensure_project()
+
         if sys.argv[2] == "last":
             count = 0
             if self.memory.last is not None:
@@ -26,10 +29,9 @@ class Count(BaseCommand):
         return self
 
     def usage(self):
-        self.conversation.display_project(self.configuration.project.name)
+        self.configuration.display_project()
         self.conversation.type(
-            f"usage: {self.configuration.command} count [which memory]\n"
-            + '  where [which memory] is one of "last" or "stored"\n'
+            f"usage: {command(self.configuration.command)} {subcommand('count')} {arguments(['last', 'stored'])} {hint('display the number of entities')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/Dev.py

@@ -2,6 +2,7 @@ import os
 import sys
 
 from gibson.command.BaseCommand import BaseCommand
+from gibson.core.Colors import arguments, command, hint, subcommand
 from gibson.lang.Python import Python
 
 
@@ -29,13 +30,15 @@ class Dev(BaseCommand):
         if len(sys.argv) != 3 or sys.argv[2] not in ["off", "on"]:
             self.usage()
 
+        self.configuration.ensure_project()
+
         if sys.argv[2] == "off":
             if self.configuration.project.dev.active is True:
                 self.configuration.turn_dev_off()
 
             self.off()
 
-        self.conversation.display_project(self.configuration.project.name)
+        self.configuration.display_project()
         self.conversation.type(
             "Leveling up. Nice! I need a little context to make sure I write "
             + "code\nin the correct place. Then I will need you to tell me "
@@ -108,13 +111,15 @@ class Dev(BaseCommand):
         return self
 
     def off(self):
-        self.conversation.display_project(self.configuration.project.name)
+        self.configuration.display_project()
         self.conversation.type("Dev Mode is off!\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} dev [off | on]\n")
+        self.configuration.display_project()
+        self.conversation.type(
+            f"usage: {command(self.configuration.command)} {subcommand('dev')} {arguments(['off', 'on'])} {hint('turn dev mode on or off')}\n"
+        )
         self.conversation.newline()
         exit(1)

gibson/command/Forget.py

@@ -1,6 +1,7 @@
 import sys
 
-from .BaseCommand import BaseCommand
+from gibson.command.BaseCommand import BaseCommand
+from gibson.core.Colors import arguments, command, hint, subcommand
 
 
 class Forget(BaseCommand):
@@ -8,27 +9,25 @@ class Forget(BaseCommand):
         if len(sys.argv) != 3 or sys.argv[2] not in ["all", "last", "stored"]:
             self.usage()
 
-        if sys.argv[2] == "all":
-            self.memory.forget_last()
-            self.memory.forget_entities()
-        elif sys.argv[2] == "last":
+        self.configuration.ensure_project()
+        self.configuration.display_project()
+
+        if sys.argv[2] in ["all", "last"]:
             self.memory.forget_last()
-        elif sys.argv[2] == "stored":
+            self.conversation.type(f"last memory is forgotten.\n")
+
+        if sys.argv[2] in ["all", "stored"]:
             self.memory.forget_entities()
-        else:
-            raise NotImplementedError
+            self.conversation.type(f"stored memory is forgotten.\n")
 
-        self.conversation.display_project(self.configuration.project.name)
-        self.conversation.type("Yeah man, forgotten.\n")
         self.conversation.newline()
 
         return self
 
     def usage(self):
-        self.conversation.display_project(self.configuration.project.name)
+        self.configuration.display_project()
         self.conversation.type(
-            f"usage: {self.configuration.command} forget [which memory]\n"
-            + '  where [which memory] is one of "all", "last" or "stored"\n'
+            f"usage: {command(self.configuration.command)} {subcommand('forget')} {arguments(['all', 'last', 'stored'])} {hint('delete entities from memory')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/Help.py

@@ -0,0 +1,125 @@
+import gibson.core.Colors as Colors
+from gibson.command.BaseCommand import BaseCommand
+from gibson.core.Memory import Memory
+
+
+class Help(BaseCommand):
+    def execute(self):
+        dev_off = ""
+        dev_on = ""
+
+        if self.configuration.project is not None:
+            dev_off = "*" if self.configuration.project.dev.active is False else ""
+            dev_on = "*" if self.configuration.project.dev.active is True else ""
+
+        subcommands = {
+            "auth": {
+                "description": "login | logout",
+                "memory": None,
+            },
+            "build": {
+                "description": "create the entities in the datastore",
+                "memory": "stored",
+            },
+            "code": {"description": "pair program", "memory": None},
+            "conf": {"description": "set a configuration variable", "memory": None},
+            "count": {
+                "description": "show the number of entities stored",
+                "memory": "last | stored",
+            },
+            "dev": {
+                "description": f"mode off{dev_off} | on{dev_on}",
+                "memory": None,
+            },
+            "forget": {
+                "description": "delete memory",
+                "memory": "all | last | stored",
+            },
+            "help": {"description": "for help", "memory": None},
+            "import": {
+                "description": "configure from a data source",
+                "memory": "stored",
+            },
+            "list": {
+                "description": "show the names of entities in your project",
+                "memory": None,
+            },
+            "merge": {
+                "description": "move last changes into project",
+                "memory": "last -> stored",
+            },
+            "model": {
+                "description": "write the model code for an entity",
+                "memory": "stored",
+            },
+            "modify": {
+                "description": "change an entity using natural language",
+                "memory": "last > stored",
+            },
+            "module": {"description": "create a new module", "memory": "last"},
+            "new": {"description": "start something new", "memory": None},
+            "openapi": {"description": "build from an OpenAPI spec", "memory": "last"},
+            "remove": {
+                "description": "remove an entity from the project",
+                "memory": "last > stored",
+            },
+            "rename": {
+                "description": "rename an entity",
+                "memory": "last > stored",
+            },
+            "rewrite": {
+                "description": "rewrite code",
+                "memory": "stored",
+            },
+            "schema": {
+                "description": "write the schema code for an entity",
+                "memory": "stored",
+            },
+            "show": {"description": "display an entity", "memory": "last > stored"},
+            "test": {
+                "description": "write the unit tests for an entity",
+                "memory": "stored",
+            },
+            "tree": {"description": "illustrate the project layout", "memory": None},
+            "? | q": {"description": "ask a question", "memory": None},
+        }
+
+        self.conversation.set_delay(0.001)
+        self.configuration.display_project()
+        self.conversation.type(
+            f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('[command]')}\n\n"
+        )
+        self.conversation.type(" command  description" + " " * 40 + "memory\n")
+        self.conversation.type(" -------  -----------" + " " * 40 + "------\n")
+
+        for subcommand, config in subcommands.items():
+            memory = ""
+            if config["memory"] is not None:
+                memory = f"[{config['memory']}]"
+
+            spaces = 61 - (8 + 2 + len(config["description"]))
+
+            self.conversation.type(
+                f"{Colors.subcommand(subcommand.rjust(8))}"
+                + f"  {config['description']}"
+                + " " * spaces
+                + f"{Colors.hint(memory)}\n"
+            )
+
+        self.conversation.newline()
+
+        if self.configuration.project is not None:
+            self.conversation.type("memory:\n\n")
+            stats = Memory(self.configuration).stats()
+            self.conversation.type(
+                f"{str(stats['entities']['num']).rjust(8)}"
+                + f"  {stats['entities']['word']}"
+                + " " * (43 if stats["entities"]["word"] == "entities" else 45)
+                + "[stored]\n"
+            )
+            self.conversation.type(
+                f"{str(stats['last']['num']).rjust(8)}"
+                + f"  {stats['last']['word']}"
+                + " " * (43 if stats["last"]["word"] == "entities" else 45)
+                + "[last]\n\n"
+            )

gibson/command/Import.py

@@ -6,6 +6,7 @@ from sqlalchemy.orm import sessionmaker
 from gibson.api.Cli import Cli
 from gibson.command.BaseCommand import BaseCommand
 from gibson.command.rewrite.Rewrite import Rewrite
+from gibson.core.Colors import argument, arguments, command, hint, option, subcommand
 from gibson.db.TableExceptions import TableExceptions
 
 
@@ -14,13 +15,14 @@ class Import(BaseCommand):
         if len(sys.argv) != 3 and len(sys.argv) != 5:
             self.usage()
 
+        self.configuration.ensure_project()
         write_code = False
         if len(sys.argv) == 5:
             if sys.argv[3] != ".." or sys.argv[4] != "dev":
                 self.usage()
 
             if self.configuration.project.dev.active is False:
-                self.conversation.display_project(self.configuration.project.name)
+                self.configuration.display_project()
                 self.conversation.type(
                     "Dude, seriously?! You have Dev Mode turned off. "
                     + "Why would you do that?\n"
@@ -54,7 +56,7 @@ class Import(BaseCommand):
         return True
 
     def __import_from_api(self):
-        self.conversation.display_project(self.configuration.project.name)
+        self.configuration.display_project()
 
         self.conversation.type("Connected to API...\n")
         response = Cli(self.configuration).import_()
@@ -67,7 +69,7 @@ class Import(BaseCommand):
         return response["project"]["entities"]
 
     def __import_from_datastore(self):
-        self.conversation.display_project(self.configuration.project.name)
+        self.configuration.display_project()
 
         db = create_engine(self.configuration.project.datastore.uri)
         session = sessionmaker(autocommit=False, autoflush=False, bind=db)()
@@ -97,12 +99,20 @@ class Import(BaseCommand):
         return entities
 
     def usage(self):
-        self.conversation.display_project(self.configuration.project.name)
+        self.configuration.display_project()
+        datastore_uri = (
+            self.configuration.project.datastore.uri
+            if self.configuration.project
+            else ""
+        )
+        self.conversation.type(
+            f"usage: {command(self.configuration.command)} {subcommand('import')} {argument('api')} {hint('import all entities from your project created on GibsonAI.com')}\n"
+        )
+        self.conversation.type(
+            f"   or: {command(self.configuration.command)} {subcommand('import')} {argument('datastore')} {hint('import all entities from your local datastore')} {datastore_uri}\n"
+        )
         self.conversation.type(
-            f"usage: {self.configuration.command} import [api | datastore] {{.. dev}}"
-            + "\n  api = the project stored in your API key on GibsonAI.com\n"
-            + f"  datastore = {self.configuration.project.datastore.uri}\n"
-            + "  {.. dev} have Dev Mode write all the code\n"
+            f"   or: {command(self.configuration.command)} {subcommand('import')} {arguments(['api', 'datastore'])} {option('.. dev')} {hint('have dev mode write all the code')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/List.py

@@ -2,6 +2,7 @@ import sys
 
 from gibson.api.Cli import Cli
 from gibson.command.BaseCommand import BaseCommand
+from gibson.core.Colors import arguments, command, hint, subcommand
 
 
 class List(BaseCommand):
@@ -9,7 +10,8 @@ class List(BaseCommand):
         if len(sys.argv) != 3:
             self.usage()
 
-        self.conversation.display_project(self.configuration.project.name)
+        self.configuration.ensure_project()
+        self.configuration.display_project()
 
         entities = {"last": [], "stored": []}
 
@@ -54,7 +56,9 @@ class List(BaseCommand):
                 self.conversation.newline()
 
     def usage(self):
-        self.conversation.display_project(self.configuration.project.name)
-        self.conversation.type(f"usage: {self.configuration.command} list entities\n")
+        self.configuration.display_project()
+        self.conversation.type(
+            f"usage: {command(self.configuration.command)} {subcommand('list')} {arguments(['entities'])} {hint('list all entities')}\n"
+        )
         self.conversation.newline()
         exit(1)

gibson/command/Merge.py

@@ -1,12 +1,10 @@
-import sys
-
-from gibson.api.Cli import Cli
 from gibson.command.BaseCommand import BaseCommand
 
 
 class Merge(BaseCommand):
     def execute(self):
-        self.conversation.display_project(self.configuration.project.name)
+        self.configuration.ensure_project()
+        self.configuration.display_project()
 
         if self.memory.last is None or "entities" not in self.memory.last:
             self.conversation.type("No bueno. There is nothing to merge.\n\n")

gibson/command/Model.py

@@ -2,6 +2,7 @@ import sys
 
 from gibson.api.Cli import Cli
 from gibson.command.BaseCommand import BaseCommand
+from gibson.core.Colors import command, hint, input, subcommand
 from gibson.core.TimeKeeper import TimeKeeper
 from gibson.dev.Dev import Dev
 
@@ -11,6 +12,7 @@ class Model(BaseCommand):
         if len(sys.argv) != 3:
             self.usage()
 
+        self.configuration.ensure_project()
         entity = self.memory.recall_stored_entity(sys.argv[2])
         if entity is None:
             self.conversation.not_sure_no_entity(
@@ -31,11 +33,9 @@ class Model(BaseCommand):
         time_keeper.display()
 
     def usage(self):
-        self.conversation.display_project(self.configuration.project.name)
+        self.configuration.display_project()
         self.conversation.type(
-            f"usage: {self.configuration.command} model [entity name]\n"
-            + "  where [entity name] is one of the entities that exists "
-            + "in this project\n"
+            f"usage: {command(self.configuration.command)} {subcommand('model')} {input('[entity name]')} {hint('generate the model for an entity')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/Modify.py

@@ -2,6 +2,7 @@ import sys
 
 from gibson.api.Cli import Cli
 from gibson.command.BaseCommand import BaseCommand
+from gibson.core.Colors import argument, command, hint, input, subcommand
 
 
 class Modify(BaseCommand):
@@ -9,6 +10,7 @@ class Modify(BaseCommand):
         if len(sys.argv) < 4:
             self.usage()
 
+        self.configuration.ensure_project()
         entity = self.memory.recall_entity(sys.argv[2])
         if entity is None:
             self.conversation.not_sure_no_entity(
@@ -30,13 +32,9 @@ class Modify(BaseCommand):
         print(response["entities"][0]["definition"])
 
     def usage(self):
-        self.conversation.display_project(self.configuration.project.name)
+        self.configuration.display_project()
         self.conversation.type(
-            f"usage: {self.configuration.command} "
-            + "modify [entity name] [instructions]\n"
-            + "  where [entity name] is one of the entities that exists in "
-            + "this project\n"
-            + "  and [instructions] is natural language describing the changes\n"
+            f"usage: {command(self.configuration.command)} {subcommand('modify')} {argument('[entity name]')} {input('[instructions]')} {hint('modify an entity with natural language instructions')}\n"
         )
         self.conversation.newline()
         exit(1)