gibson-cli 0.7.4__py3-none-any.whl → 0.7.6__py3-none-any.whl

bin/gibson

@@ -0,0 +1,26 @@
+#!/Library/Frameworks/Python.framework/Versions/3.9/bin/python3.9
+# -*- coding: utf-8 -*-
+
+# This file is identical to what pip creates when you install an executable package, but it adds a dev mode banner.
+# To easily switch between dev mode and installed mode, add the following functions to your .zshrc or .bashrc:
+#
+# cli_dev_on() {
+#   export PATH="$HOME/src/gibson/cli/bin:$PATH"
+#   export PYTHONPATH="$HOME/src/gibson/cli:$PYTHONPATH"
+# }
+#
+# cli_dev_off() {
+#   export PATH=${PATH#$HOME/src/gibson/cli/bin:}
+#   export PYTHONPATH=${PYTHONPATH#:$HOME/src/gibson/cli:}
+# }
+
+import re
+import sys
+
+from gibson.bin.gibson import main
+from gibson.display.Header import Header
+
+if __name__ == "__main__":
+    print(f"{Header().render('dev mode')}\n")
+    sys.argv[0] = re.sub(r"(-script\.pyw|\.exe)?$", "", sys.argv[0])
+    sys.exit(main())

gibson/api/BaseApi.py

@@ -86,7 +86,7 @@ class BaseApi:
     def __raise_for_status(self, r):
         if r.status_code == 401:
             self.configuration.conversation.type(
-                f"\nYou need to log in to continue. Please run {Colors.command('gibson')} {Colors.subcommand('auth')} {Colors.argument('login')} and then try again.\n"
+                f"\nYou need to log in to continue. Please run {Colors.command(self.configuration.command, 'auth', args='login')} and then try again.\n"
             )
             exit(1)
 

gibson/api/Cli.py

@@ -11,7 +11,7 @@ class Cli(BaseApi):
         self.configuration = configuration
         self.configuration.require_login()
         self.configuration.require_project()
-        self.configuration.require_project_key()
+        self.configuration.require_project_key_or_id()
 
     def code_api(self):
         return self.post(

gibson/command/Build.py

@@ -39,13 +39,13 @@ class Build(BaseCommand):
 
                 for table in tables:
                     if table not in table_exceptions:
-                        self.conversation.type(f"    {table[0]}\n", delay=0.002)
+                        self.conversation.type(f"    {table[0]}\n")
                         session.execute(f"drop table if exists {table[0]}")
 
             self.conversation.type("  building entities\n")
 
             for entity in self.memory.entities:
-                self.conversation.type(f"    {entity['name']}\n", delay=0.002)
+                self.conversation.type(f"    {entity['name']}\n")
                 session.execute(entity["definition"])
         finally:
             session.execute("set foreign_key_checks = 1")
@@ -61,7 +61,7 @@ class Build(BaseCommand):
             session.execute(
                 """select table_name
                      from information_schema.tables
-                    where table_schema = :table_schema""",
+                    where table_schema = :table_schema and table_type = 'BASE TABLE'""",
                 {"table_schema": schema},
             )
         )
@@ -70,7 +70,7 @@ class Build(BaseCommand):
             self.conversation.type("  dropping existing entities\n")
 
             for table in tables:
-                self.conversation.type(f"    {table[0]}\n", delay=0.002)
+                self.conversation.type(f"    {table[0]}\n")
                 session.execute(f"drop table if exists {schema}.{table[0]} cascade")
                 session.commit()
 
@@ -88,7 +88,7 @@ class Build(BaseCommand):
                     session.execute(definition)
                     session.commit()
 
-                    self.conversation.type(f'    {name.split(".")[-1]}\n', delay=0.002)
+                    self.conversation.type(f'    {name.split(".")[-1]}\n')
 
                     remove.append(name)
                 except sqlalchemy.exc.ProgrammingError:
@@ -124,7 +124,7 @@ class Build(BaseCommand):
             else ""
         )
         self.conversation.type(
-            f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('build')} {Colors.argument('datastore')} {Colors.hint('build the datastore')} {datastore_uri}\n"
+            f"usage: {Colors.command(self.configuration.command, 'build', args='datastore', hint='build the datastore')} {datastore_uri}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/Conf.py

@@ -61,13 +61,12 @@ class Conf(BaseCommand):
     def usage(self):
         self.configuration.display_project()
         self.conversation.type(
-            f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('conf')} {Colors.argument('[key]')} {Colors.input('[value]')} {Colors.hint('set a configuration value')}\n"
+            f"usage: {Colors.command(self.configuration.command, 'conf', args='[key]', inputs='[value]', hint='set a configuration value')}\n"
         )
         self.conversation.newline()
 
         if self.configuration.project:
             self.conversation.type(f"  where {Colors.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")

gibson/command/Count.py

@@ -31,7 +31,7 @@ class Count(BaseCommand):
     def usage(self):
         self.configuration.display_project()
         self.conversation.type(
-            f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('count')} {Colors.arguments(['last', 'stored'])} {Colors.hint('display the number of entities')}\n"
+            f"usage: {Colors.command(self.configuration.command, 'count', args=['last', 'stored'], hint='display the number of entities')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/Dev.py

@@ -72,16 +72,13 @@ class Dev(BaseCommand):
             except FileExistsError:
                 pass
 
-        self.conversation.type(
-            "\n  https://api.yourdomain.com/v1/-/sneakers GET\n", delay=0.002
-        )
-        self.conversation.type("                             ^  ^\n", delay=0.002)
-        self.conversation.type("                             |  |\n", delay=0.002)
-        self.conversation.type("                    version _|  |\n", delay=0.002)
+        self.conversation.type("\n  https://api.yourdomain.com/v1/-/sneakers GET\n")
+        self.conversation.type("                             ^  ^\n")
+        self.conversation.type("                             |  |\n")
+        self.conversation.type("                    version _|  |\n")
         self.conversation.type(
             "                                |_ prefix (to isolate GibsonAI "
             + "API routes)\n\n",
-            delay=0.002,
         )
         self.conversation.type(
             "  It is OK if you are not sure about these. Just leave the defaults\n"
@@ -119,7 +116,7 @@ class Dev(BaseCommand):
     def usage(self):
         self.configuration.display_project()
         self.conversation.type(
-            f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('dev')} {Colors.arguments(['off', 'on'])} {Colors.hint('turn dev mode on or off')}\n"
+            f"usage: {Colors.command(self.configuration.command, 'dev', args=['off', 'on'], hint='turn dev mode on or off')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/Forget.py

@@ -27,7 +27,7 @@ class Forget(BaseCommand):
     def usage(self):
         self.configuration.display_project()
         self.conversation.type(
-            f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('forget')} {Colors.arguments(['all', 'last', 'stored'])} {Colors.hint('delete entities from memory')}\n"
+            f"usage: {Colors.command(self.configuration.command, 'forget', args=['all', 'last', 'stored'], hint='delete entities from memory')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/Help.py

@@ -1,3 +1,8 @@
+from rich import box
+from rich.console import Console
+from rich.table import Table
+from rich.text import Text
+
 import gibson.core.Colors as Colors
 from gibson.command.BaseCommand import BaseCommand
 from gibson.core.Memory import Memory
@@ -5,107 +10,167 @@ from gibson.core.Memory import Memory
 
 class Help(BaseCommand):
     def execute(self):
-        dev_off = ""
-        dev_on = ""
+        dev_mode_text = []
 
         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 ""
+            dev_mode = "on" if self.configuration.project.dev.active is True else "off"
+            dev_color = (
+                "green" if self.configuration.project.dev.active is True else "red"
+            )
+            dev_mode_text = [
+                "\n\ndev mode is turned ",
+                (dev_mode, f"bold {dev_color}"),
+            ]
 
         subcommands = {
             "auth": {
-                "description": "login | logout",
+                "description": "authenticate with the gibson cli",
+                "subcommands": ["login", "logout"],
                 "memory": None,
             },
             "build": {
                 "description": "create the entities in the datastore",
+                "subcommands": ["datastore"],
                 "memory": "stored",
             },
-            "code": {"description": "pair program with gibson", "memory": None},
-            "conf": {"description": "set a configuration variable", "memory": None},
+            "code": {
+                "description": "pair program with gibson",
+                "subcommands": ["api", "base", "entity", "models", "schemas", "tests"],
+                "memory": None,
+            },
+            "conf": {
+                "description": "set a configuration variable",
+                "subcommands": None,
+                "memory": None,
+            },
             "count": {
                 "description": "show the number of entities stored",
-                "memory": "last | stored",
+                "subcommands": ["last", "stored"],
+                "memory": "based on user selection",
             },
             "dev": {
-                "description": f"mode off{dev_off} | on{dev_on}",
+                "description": Text.assemble(
+                    "gibson will automatically write code for you",
+                    *dev_mode_text,
+                ),
+                "subcommands": ["on", "off"],
                 "memory": None,
             },
             "forget": {
-                "description": "delete memory",
-                "memory": "all | last | stored",
+                "description": f"delete entities from memory",
+                "subcommands": ["all", "last", "stored"],
+                "memory": "based on user selection",
             },
-            "help": {"description": "for help", "memory": None},
+            "help": {"description": "for help", "subcommands": None, "memory": None},
             "import": {
-                "description": "import entities from a data source",
+                "description": "import entities from a datasource",
+                "subcommands": ["api", "mysql", "pg_dump", "openapi"],
                 "memory": "stored",
             },
             "list": {
-                "description": "show the names of entities in your project",
+                "description": "see a list of your entities or projects",
+                "subcommands": ["entities", "projects"],
                 "memory": None,
             },
             "merge": {
-                "description": "move last changes into project",
+                "description": "merge last memory (recent changes) into stored project memory",
+                "subcommands": None,
                 "memory": "last -> stored",
             },
             "modify": {
                 "description": "change an entity using natural language",
+                "subcommands": None,
                 "memory": "last > stored",
             },
-            "new": {"description": "create something new", "memory": None},
+            "new": {
+                "description": "create something new",
+                "subcommands": ["project", "module", "entity"],
+                "memory": None,
+            },
             "remove": {
                 "description": "remove an entity from the project",
+                "subcommands": None,
                 "memory": "last > stored",
             },
             "rename": {
                 "description": "rename an entity",
+                "subcommands": ["entity"],
                 "memory": "last > stored",
             },
             "rewrite": {
                 "description": "rewrite all code",
+                "subcommands": None,
                 "memory": "stored",
             },
-            "show": {"description": "display an entity", "memory": "last > stored"},
-            "tree": {"description": "illustrate the project layout", "memory": None},
-            "q": {"description": "ask Gibson a question", "memory": None},
+            "show": {
+                "description": "display an entity",
+                "subcommands": None,
+                "memory": "last > stored",
+            },
+            "tree": {
+                "description": "illustrate the project layout in a tree view",
+                "subcommands": None,
+                "memory": None,
+            },
+            "q": {
+                "description": "ask gibson a question using natural language",
+                "subcommands": None,
+                "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']}]"
+        console = Console()
 
-            spaces = 61 - (8 + 2 + len(config["description"]))
+        help = Table(
+            title=Text.assemble(
+                "usage: ",
+                (self.configuration.command, "green bold"),
+                (" [command]", "yellow bold"),
+                (" [subcommand]", "magenta bold"),
+            ),
+            header_style="bold",
+            box=box.ROUNDED,
+            expand=True,
+            leading=1,
+        )
+        help.add_column("command", style="yellow bold", header_style="yellow bold")
+        help.add_column("description")
+        help.add_column("subcommands", header_style="magenta")
+        help.add_column("memory affected", style="grey50", header_style="grey50")
 
-            self.conversation.type(
-                f"{Colors.subcommand(subcommand.rjust(8))}"
-                + f"  {config['description']}"
-                + " " * spaces
-                + f"{Colors.hint(memory)}\n"
+        for subcommand, config in subcommands.items():
+            help.add_row(
+                subcommand,
+                config["description"],
+                (
+                    Text(" | ").join(
+                        Text(x, style="magenta") for x in config["subcommands"]
+                    )
+                    if config["subcommands"]
+                    else ""
+                ),
+                config["memory"] or "",
             )
 
+        console.print(help)
+
         self.conversation.newline()
 
-        if self.configuration.project is not None:
-            self.conversation.type("memory:\n\n")
+        if self.configuration.project:
             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"
+            memory = Table(
+                title="Memory",
+                show_header=True,
+                header_style="bold",
+                box=box.ROUNDED,
+                expand=True,
             )
-            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"
+            memory.add_column("stored", style="green", header_style="green")
+            memory.add_column("last", style="yellow", header_style="yellow")
+            memory.add_row(
+                f"{stats['entities']['num']} {stats['entities']['word']}",
+                f"{stats['last']['num']} {stats['last']['word']}",
             )
+            console.print(memory)

gibson/command/Modify.py

@@ -13,9 +13,7 @@ class Modify(BaseCommand):
         self.configuration.require_project()
         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]
-            )
+            self.conversation.not_sure_no_entity(self.configuration, sys.argv[2])
             exit(1)
 
         cli = Cli(self.configuration)
@@ -34,7 +32,7 @@ class Modify(BaseCommand):
     def usage(self):
         self.configuration.display_project()
         self.conversation.type(
-            f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('modify')} {Colors.argument('[entity name]')} {Colors.input('[instructions]')} {Colors.hint('modify an entity with natural language instructions')}\n"
+            f"usage: {Colors.command(self.configuration.command, 'modify', inputs=['[entity name]', '[instructions]'], hint='modify an entity with natural language instructions')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/Question.py

@@ -57,9 +57,7 @@ class Question(BaseCommand):
 
                 entity = self.memory.recall_entity(name)
                 if entity is None:
-                    self.conversation.not_sure_no_entity(
-                        self.configuration.project.name, name
-                    )
+                    self.conversation.not_sure_no_entity(self.configuration, name)
                     exit(1)
 
                 has_sql = True
@@ -93,7 +91,7 @@ class Question(BaseCommand):
     def usage(self):
         self.configuration.display_project()
         self.conversation.type(
-            f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('q')} {Colors.input('[instructions]')} {Colors.hint('ask a question or tell Gibson to do something using natural language')}\n"
+            f"usage: {Colors.command(self.configuration.command, 'q', inputs='[instructions]', hint='ask a question or tell Gibson to do something using natural language')}\n"
         )
         self.conversation.type(
             f"    use {Colors.argument(self.TOKEN_FILE+'[path]')} to import a file from the filesystem\n"

gibson/command/Remove.py

@@ -50,7 +50,7 @@ class Remove(BaseCommand):
 
         if not found:
             self.conversation.type(
-                f'Nothing removed, did not find entity named "{sys.argv[2]}".\n'
+                f"Nothing removed, no entity named {Colors.entity(sys.argv[2])}.\n"
             )
             self.conversation.newline()
             return self
@@ -76,7 +76,7 @@ class Remove(BaseCommand):
     def usage(self):
         self.configuration.display_project()
         self.conversation.type(
-            f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('remove')} {Colors.input('[entity name]')} {Colors.hint('remove an entity from the project')}\n"
+            f"usage: {Colors.command(self.configuration.command, 'remove', inputs='[entity name]', hint='remove an entity from the project')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/Show.py

@@ -16,9 +16,7 @@ class Show(BaseCommand):
             self.configuration.require_project()
             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]
-                )
+                self.conversation.not_sure_no_entity(self.configuration, sys.argv[2])
                 exit(1)
 
             entities = [entity]
@@ -32,10 +30,10 @@ class Show(BaseCommand):
     def usage(self):
         self.configuration.display_project()
         self.conversation.type(
-            f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('show')} {Colors.hint('display the entire schema')}\n"
+            f"usage: {Colors.command(self.configuration.command, 'show', hint='display the entire schema')}\n"
         )
         self.conversation.type(
-            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('show')} {Colors.argument('[entity name]')} {Colors.hint('display the schema for an entity')}\n"
+            f"       {Colors.command(self.configuration.command, 'show', inputs='[entity name]', hint='display the schema for an entity')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/Version.py

@@ -21,7 +21,7 @@ class Version(BaseCommand):
                 f"You are currently using version: {Colors.violet(VersionConf.num)}\n"
             )
             self.conversation.type(
-                f"Please update to the latest version by running: {Colors.command('pip3')} {Colors.subcommand('install')} {Colors.option('--upgrade')} gibson-cli\n"
+                f"Please update to the latest version by running: {Colors.command('pip3', 'install', args='--upgrade', inputs='gibson-cli')}\n"
             )
         else:
             self.conversation.type(

gibson/command/auth/Auth.py

@@ -20,13 +20,13 @@ class Auth(BaseCommand):
     def usage(self):
         self.configuration.display_project()
         self.conversation.type(
-            f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('auth')} {Colors.arguments(['login', 'logout'])}\n"
+            f"usage: {Colors.command(self.configuration.command, 'auth', args=['login', 'logout'])}\n"
         )
         self.conversation.type(
-            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('auth')} {Colors.argument('login')} {Colors.hint('login to Gibson')}\n"
+            f"       {Colors.command(self.configuration.command, 'auth', args='login', hint='login to Gibson')}\n"
         )
         self.conversation.type(
-            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('auth')} {Colors.argument('logout')} {Colors.hint('logout of Gibson')}\n"
+            f"       {Colors.command(self.configuration.command, 'auth', args='logout', hint='logout of Gibson')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/code/Code.py

@@ -39,34 +39,34 @@ class Code(BaseCommand):
     def usage(self):
         self.configuration.display_project()
         self.conversation.type(
-            f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('code')} {Colors.arguments(['api', 'base', 'entity', 'models', 'schemas', 'tests'])} {Colors.input('[entity name]')} {Colors.hint('write code')}\n"
+            f"usage: {Colors.command(self.configuration.command, 'code', args=['api', 'base', 'entity', 'models', 'schemas', 'tests'], inputs='[entity name]', hint='write code')}\n"
         )
         self.conversation.type(
-            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('code')} {Colors.argument('api')} {Colors.hint('generate the API code')}\n"
+            f"       {Colors.command(self.configuration.command, 'code', args='api', hint='generate the API code')}\n"
         )
         self.conversation.type(
-            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('code')} {Colors.argument('base')} {Colors.hint('generate the base code')}\n"
+            f"       {Colors.command(self.configuration.command, 'code', args='base', hint='generate the base code')}\n"
         )
         self.conversation.type(
-            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('code')} {Colors.argument('entity')} {Colors.input('[entity name]')} {Colors.hint('create or update an entity using the AI pair programmer')}\n"
+            f"       {Colors.command(self.configuration.command, 'code', args='entity', inputs='[entity name]', hint='create or update an entity using the AI pair programmer')}\n"
         )
         self.conversation.type(
-            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('code')} {Colors.argument('models')} {Colors.hint('generate the models for all entities')}\n"
+            f"       {Colors.command(self.configuration.command, 'code', args='models', hint='generate the models for all entities')}\n"
         )
         self.conversation.type(
-            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('code')} {Colors.argument('models')} {Colors.input('[entity name]')} {Colors.hint('generate the model(s) for a single entity')}\n"
+            f"       {Colors.command(self.configuration.command, 'code', args='models', inputs='[entity name]', hint='generate the model(s) for a single entity')}\n"
         )
         self.conversation.type(
-            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('code')} {Colors.argument('schemas')} {Colors.hint('generate the schemas for all entities')}\n"
+            f"       {Colors.command(self.configuration.command, 'code', args='schemas', hint='generate the schemas for all entities')}\n"
         )
         self.conversation.type(
-            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('code')} {Colors.argument('schemas')} {Colors.input('[entity name]')} {Colors.hint('generate the schema(s) for a single entity')}\n"
+            f"       {Colors.command(self.configuration.command, 'code', args='schemas', inputs='[entity name]', hint='generate the schema(s) for a single entity')}\n"
         )
         self.conversation.type(
-            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('code')} {Colors.argument('tests')} {Colors.hint('generate the unit tests for all entities')}\n"
+            f"       {Colors.command(self.configuration.command, 'code', args='tests', hint='generate the unit tests for all entities')}\n"
         )
         self.conversation.type(
-            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('code')} {Colors.argument('tests')} {Colors.input('[entity name]')} {Colors.hint('generate the unit tests for a single entity')}\n"
+            f"       {Colors.command(self.configuration.command, 'code', args='tests', inputs='[entity name]', hint='generate the unit tests for a single entity')}\n"
         )
         self.conversation.newline()
         exit(1)