gibson-cli 0.7.5__tar.gz → 0.7.7__tar.gz

{gibson_cli-0.7.5/gibson_cli.egg-info → gibson_cli-0.7.7}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: gibson-cli
-Version: 0.7.5
+Version: 0.7.7
 Summary: Gibson Command Line Interface
 Author-email: GibsonAI <noc@gibsonai.com>
 Project-URL: Homepage, https://gibsonai.com/
@@ -50,12 +50,13 @@ Requires-Dist: python-dotenv==1.0.1
 Requires-Dist: python-multipart==0.0.9
 Requires-Dist: PyYAML==6.0.1
 Requires-Dist: requests==2.31.0
-Requires-Dist: rich==13.7.1
+Requires-Dist: rich==13.9.2
 Requires-Dist: shellingham==1.5.4
 Requires-Dist: six==1.16.0
 Requires-Dist: sniffio==1.3.1
 Requires-Dist: SQLAlchemy==1.4.41
 Requires-Dist: starlette==0.37.2
+Requires-Dist: textual==0.83.0
 Requires-Dist: tomli==2.0.1
 Requires-Dist: typer==0.12.3
 Requires-Dist: typing_extensions==4.9.0
@@ -84,12 +85,20 @@ Portions of the Gibson backend code are written by Gibson.  So far, versus a hum
 
 ## Installation / Upgrading
 
-Install the latest version of the CLI using pip.
+Install the latest version of the CLI using `pip`
 
 ```sh
 pip3 install gibson-cli --upgrade
 ```
 
+Note: the first time you install any package from PyPI via `pip` that includes an executable, it is placed in a directory that is likely not in your `PATH`. There are a number of ways to do this, but one method is to run the following command:
+
+```sh
+echo 'export PATH="$PATH:${$(which python3)%python3}"' >> ~/.zshrc # or ~/.bashrc
+```
+
+You will only need to do this once.
+
 ## Key Terms
 
 - Dev Mode

{gibson_cli-0.7.5 → gibson_cli-0.7.7}/README.md

@@ -15,12 +15,20 @@ Portions of the Gibson backend code are written by Gibson.  So far, versus a hum
 
 ## Installation / Upgrading
 
-Install the latest version of the CLI using pip.
+Install the latest version of the CLI using `pip`
 
 ```sh
 pip3 install gibson-cli --upgrade
 ```
 
+Note: the first time you install any package from PyPI via `pip` that includes an executable, it is placed in a directory that is likely not in your `PATH`. There are a number of ways to do this, but one method is to run the following command:
+
+```sh
+echo 'export PATH="$PATH:${$(which python3)%python3}"' >> ~/.zshrc # or ~/.bashrc
+```
+
+You will only need to do this once.
+
 ## Key Terms
 
 - Dev Mode

gibson_cli-0.7.7/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_cli-0.7.5 → gibson_cli-0.7.7}/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_cli-0.7.5 → gibson_cli-0.7.7}/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_cli-0.7.5 → gibson_cli-0.7.7}/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_cli-0.7.5 → gibson_cli-0.7.7}/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_cli-0.7.5 → gibson_cli-0.7.7}/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_cli-0.7.5 → gibson_cli-0.7.7}/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_cli-0.7.5 → gibson_cli-0.7.7}/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_cli-0.7.7/gibson/command/Help.py

@@ -0,0 +1,176 @@
+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
+
+
+class Help(BaseCommand):
+    def execute(self):
+        dev_mode_text = []
+
+        if self.configuration.project is not None:
+            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": "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",
+                "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",
+                "subcommands": ["last", "stored"],
+                "memory": "based on user selection",
+            },
+            "dev": {
+                "description": Text.assemble(
+                    "gibson will automatically write code for you",
+                    *dev_mode_text,
+                ),
+                "subcommands": ["on", "off"],
+                "memory": None,
+            },
+            "forget": {
+                "description": f"delete entities from memory",
+                "subcommands": ["all", "last", "stored"],
+                "memory": "based on user selection",
+            },
+            "help": {"description": "for help", "subcommands": None, "memory": None},
+            "import": {
+                "description": "import entities from a datasource",
+                "subcommands": ["api", "mysql", "pg_dump", "openapi"],
+                "memory": "stored",
+            },
+            "list": {
+                "description": "see a list of your entities or projects",
+                "subcommands": ["entities", "projects"],
+                "memory": None,
+            },
+            "merge": {
+                "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",
+                "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",
+                "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.configuration.display_project()
+
+        console = Console()
+
+        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")
+
+        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:
+            stats = Memory(self.configuration).stats()
+            memory = Table(
+                title="Memory",
+                show_header=True,
+                header_style="bold",
+                box=box.ROUNDED,
+                expand=True,
+            )
+            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_cli-0.7.5 → gibson_cli-0.7.7}/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_cli-0.7.5 → gibson_cli-0.7.7}/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_cli-0.7.5 → gibson_cli-0.7.7}/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_cli-0.7.5 → gibson_cli-0.7.7}/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_cli-0.7.5 → gibson_cli-0.7.7}/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_cli-0.7.5 → gibson_cli-0.7.7}/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_cli-0.7.5 → gibson_cli-0.7.7}/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)

{gibson_cli-0.7.5 → gibson_cli-0.7.7}/gibson/command/code/Entity.py

@@ -7,6 +7,7 @@ from string import Template
 import gibson.core.Colors as Colors
 from gibson.api.Cli import Cli
 from gibson.command.BaseCommand import BaseCommand
+from gibson.command.code.Base import Base
 from gibson.command.code.Model import Model
 from gibson.command.code.Schema import Schema
 from gibson.command.code.Test import Test
@@ -98,6 +99,7 @@ class Entity(BaseCommand):
                 self.__render_workspace(
                     original_entity,
                     entity,
+                    data["code"][0]["name"],
                     original_model_code,
                     data["code"][0]["definition"],
                 )
@@ -126,12 +128,16 @@ class Entity(BaseCommand):
                     Schema(self.configuration).execute(entity_name=entity.name)
                     Test(self.configuration).execute(entity_name=entity.name)
 
+                    if original_entity is None:
+                        # We need to ensure the testing.py file is updated to import the new entity
+                        Base(self.configuration).execute()
+
                     self.conversation.unmute()
                     self.conversation.type(
-                        f"\nAll code for the {Colors.violet(entity.name)} entity has been written 🎉\n\n"
+                        f"\nAll code for the {Colors.entity(entity.name)} entity has been written 🎉\n\n"
                     )
                     exit()
-                elif input_ == "":
+                elif input_ == "" or input_.startswith(":"):
                     continue
 
                 with ComputingSpinner():
@@ -182,6 +188,7 @@ class Entity(BaseCommand):
         self,
         original_entity: StructureEntity | None,
         entity: StructureEntity,
+        model_name: str,
         original_model_code: str | None,
         model_code: str,
     ):
@@ -208,7 +215,7 @@ class Entity(BaseCommand):
         print("")
         print(Header().render("Model", Colors.yellow))
         print("")
-        print(Colors.model(model_code_diff, entity.name))
+        print(Colors.model(model_code_diff, model_name, entity.name))
         print(WorkspaceFooter().render())
 
     def template_definition(self, entity_name):

{gibson_cli-0.7.5 → gibson_cli-0.7.7}/gibson/command/code/Model.py

@@ -14,14 +14,12 @@ class Model(BaseCommand):
         self.configuration.require_project()
         entity = self.memory.recall_stored_entity(entity_name)
         if entity is None:
-            self.conversation.not_sure_no_entity(
-                self.configuration.project.name, entity_name
-            )
+            self.conversation.not_sure_no_entity(self.configuration, entity_name)
             exit(1)
 
         time_keeper = TimeKeeper()
 
-        with Spinner("Gibson is writing the models...", "Models written"):
+        with Spinner("Gibson is writing the model...", "Model written"):
             cli = Cli(self.configuration)
             response = cli.code_models([entity["name"]])
             Dev(self.configuration).model(