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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gibson-cli
-Version: 0.7.3
+Version: 0.7.5
 Summary: Gibson Command Line Interface
 Author-email: GibsonAI <noc@gibsonai.com>
 Project-URL: Homepage, https://gibsonai.com/
@@ -65,6 +65,7 @@ Requires-Dist: uvicorn==0.29.0
 Requires-Dist: uvloop==0.19.0
 Requires-Dist: watchfiles==0.21.0
 Requires-Dist: websockets==12.0
+Requires-Dist: yaspin==3.1.0
 
 
 [![GibsonAI](https://github.com/user-attachments/assets/26bc1002-f878-4995-a6c5-eb8d5eb69c28)](https://gibsonai.com/)

gibson_cli-0.7.5/gibson/bin/gibson.py

@@ -0,0 +1,19 @@
+#!/usr/bin/env python3
+
+from gibson.core.CommandRouter import CommandRouter
+from gibson.core.Configuration import Configuration
+
+
+def main():
+    try:
+        configuration = Configuration()
+        if configuration.settings is None:
+            configuration.initialize()
+        else:
+            CommandRouter(configuration).run()
+    except KeyboardInterrupt:
+        exit(1)
+
+
+if __name__ == "__main__":
+    main()

{gibson_cli-0.7.3 → gibson_cli-0.7.5}/gibson/command/Help.py

@@ -21,7 +21,7 @@ class Help(BaseCommand):
                 "description": "create the entities in the datastore",
                 "memory": "stored",
             },
-            "code": {"description": "pair program", "memory": None},
+            "code": {"description": "pair program with gibson", "memory": None},
             "conf": {"description": "set a configuration variable", "memory": None},
             "count": {
                 "description": "show the number of entities stored",
@@ -62,7 +62,7 @@ class Help(BaseCommand):
                 "memory": "last > stored",
             },
             "rewrite": {
-                "description": "rewrite code",
+                "description": "rewrite all code",
                 "memory": "stored",
             },
             "show": {"description": "display an entity", "memory": "last > stored"},

{gibson_cli-0.7.3 → gibson_cli-0.7.5}/gibson/command/Version.py

@@ -15,15 +15,15 @@ class Version(BaseCommand):
 
         if latest_version != VersionConf.num:
             self.conversation.type(
-                f"A new version of {Colors.command(self.configuration.command)} is available: {Colors.colorize(latest_version, Colors.Color.CYAN)}\n"
+                f"A new version of {Colors.command(self.configuration.command)} is available: {Colors.cyan(latest_version)}\n"
             )
             self.conversation.type(
-                f"You are currently using version: {Colors.colorize(VersionConf.num, Colors.Color.VIOLET)}\n"
+                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"
             )
         else:
             self.conversation.type(
-                f"Nice! 🎉 You are using the latest version of {Colors.command(self.configuration.command)}: {Colors.colorize(VersionConf.num, Colors.Color.CYAN)}\n"
+                f"Nice! 🎉 You are using the latest version of {Colors.command(self.configuration.command)}: {Colors.cyan(VersionConf.num)}\n"
             )

gibson_cli-0.7.5/gibson/command/code/Entity.py

@@ -0,0 +1,231 @@
+from __future__ import annotations
+
+import os
+import sys
+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.Model import Model
+from gibson.command.code.Schema import Schema
+from gibson.command.code.Test import Test
+from gibson.command.Merge import Merge
+from gibson.core.Configuration import Configuration
+from gibson.core.Diff import additions, diff
+from gibson.core.Spinner import ComputingSpinner, Spinner
+from gibson.display.Header import Header
+from gibson.display.WorkspaceFooter import WorkspaceFooter
+from gibson.display.WorkspaceHeader import WorkspaceHeader
+from gibson.services.code.context.schema.Manager import (
+    Manager as CodeContextSchemaManager,
+)
+from gibson.structure.Entity import Entity as StructureEntity
+
+
+class Entity(BaseCommand):
+    CODE_WRITER_ENTITY_MODIFIER_NOOP = ""
+
+    def __init__(self, configuration: Configuration):
+        super().__init__(configuration)
+        self.__context = None
+
+    def __add_foreign_key(self, entity, entity_name):
+        entity_keys = self.__context.get_entity_keys(entity_name)
+        if entity_keys is None:
+            self.conversation.type(
+                f'\nThe entity you referenced, "{entity_name}", does not exist.\n'
+            )
+            self.conversation.wait()
+            return False
+
+        best_sql_foreign_key = entity_keys.best_sql_foreign_key()
+        if best_sql_foreign_key is None:
+            self.conversation.type(
+                f'\nYou cannot make a foreign key to "{entity_name}".\n'
+                + "It does not have primary or unique keys.\n"
+            )
+            self.conversation.wait()
+            return False
+
+        foreign_key, index, data_types = best_sql_foreign_key
+
+        for i in range(len(foreign_key.attributes)):
+            entity.add_attribute(
+                foreign_key.attributes[i],
+                data_types[i],
+                after="uuid",
+                before="date_created",
+            )
+
+        entity.add_foreign_key(foreign_key)
+        entity.add_index(index)
+
+        return True
+
+    def execute(self):
+        cli = Cli(self.configuration)
+        entity_name = sys.argv[3]
+        existing_entity = self.memory.recall_entity(entity_name)
+        definition = (
+            existing_entity["definition"]
+            if existing_entity
+            else self.template_definition(entity_name)
+        )
+
+        with ComputingSpinner():
+            self.__context = CodeContextSchemaManager().from_code_writer_schema_context(
+                cli.code_writer_schema_context()
+            )
+            data = cli.code_writer_entity_modifier(
+                self.__context.json,
+                sys.argv[3],
+                definition,
+                self.CODE_WRITER_ENTITY_MODIFIER_NOOP,
+            )
+            entity = (
+                StructureEntity()
+                .instantiate(self.configuration.project.datastore.type)
+                .import_from_struct(data)
+            )
+            original_entity = entity if existing_entity else None
+            original_model_code = (
+                data["code"][0]["definition"] if existing_entity else None
+            )
+
+        while True:
+            try:
+                self.__render_workspace(
+                    original_entity,
+                    entity,
+                    original_model_code,
+                    data["code"][0]["definition"],
+                )
+                input_ = input("> ")
+                if input_.lower() in [":q", ":q!", ":wq"]:
+                    self.conversation.newline()
+
+                    if input_.lower() == ":q":
+                        self.conversation.type("Exiting without saving.\n")
+
+                    if input_.lower() in [":q", ":q!"]:
+                        exit(1)
+
+                    # Mute output from individual merge + rewrite operations
+                    self.conversation.mute()
+
+                    with Spinner(
+                        "Gibson is saving your changes to the entity...",
+                        "Entity saved",
+                    ):
+                        self.memory.remember_last({"entities": [data["entity"]]})
+                        Merge(self.configuration).execute()
+
+                    # Rewrite each category of code with the new entity definition
+                    Model(self.configuration).execute(entity_name=entity.name)
+                    Schema(self.configuration).execute(entity_name=entity.name)
+                    Test(self.configuration).execute(entity_name=entity.name)
+
+                    self.conversation.unmute()
+                    self.conversation.type(
+                        f"\nAll code for the {Colors.violet(entity.name)} entity has been written 🎉\n\n"
+                    )
+                    exit()
+                elif input_ == "":
+                    continue
+
+                with ComputingSpinner():
+                    talk_to_gibsonai = True
+                    parts = input_.split(" ")
+                    if parts[0] == "fk":
+                        input_ = self.CODE_WRITER_ENTITY_MODIFIER_NOOP
+                        if not self.__add_foreign_key(entity, parts[1]):
+                            # If the entity was not modified, likely because the table
+                            # referenced does not exist or does not contain indexes which
+                            # can be used for a foreign key, do not waste the network call
+                            # to GibsonAI since there is nothing to do.
+                            talk_to_gibsonai = False
+
+                    if talk_to_gibsonai is True:
+                        data = cli.code_writer_entity_modifier(
+                            self.__context.json,
+                            data["entity"]["name"],
+                            entity.create_statement(),
+                            input_,
+                        )
+                        entity = (
+                            StructureEntity()
+                            .instantiate(self.configuration.project.datastore.type)
+                            .import_from_struct(data)
+                        )
+            except KeyboardInterrupt:
+                self.conversation.type("\nExiting without saving.\n")
+                exit(1)
+
+    def get_default_ref_table_template_path(self):
+        return (
+            os.path.dirname(__file__)
+            + "/../../data/"
+            + self.configuration.project.datastore.type
+            + "/default-ref-table.tmpl"
+        )
+
+    def get_default_table_template_path(self):
+        return (
+            os.path.dirname(__file__)
+            + "/../../data/"
+            + self.configuration.project.datastore.type
+            + "/default-table.tmpl"
+        )
+
+    def __render_workspace(
+        self,
+        original_entity: StructureEntity | None,
+        entity: StructureEntity,
+        original_model_code: str | None,
+        model_code: str,
+    ):
+        self.configuration.platform.cmd_clear()
+        create_table_statement_diff = (
+            diff(original_entity.create_statement(), entity.create_statement())
+            if original_entity
+            else additions(entity.create_statement())
+        )
+        model_code_diff = (
+            diff(original_model_code, model_code)
+            if original_model_code
+            else additions(model_code)
+        )
+
+        print("")
+        print(WorkspaceHeader().render(self.configuration.project.name))
+
+        print("")
+        print(Header().render("SQL", Colors.cyan))
+        print("")
+        print(Colors.table(create_table_statement_diff, entity.name))
+
+        print("")
+        print(Header().render("Model", Colors.yellow))
+        print("")
+        print(Colors.model(model_code_diff, entity.name))
+        print(WorkspaceFooter().render())
+
+    def template_definition(self, entity_name):
+        parts = entity_name.split("_")
+        if len(parts) > 1 and parts[1] == "ref":
+            # This is a reference table implementation. We will handle this here.
+            with open(self.get_default_ref_table_template_path()) as f:
+                definition = Template(f.read()).substitute({"entity_name": entity_name})
+
+                self.memory.append_last({"definition": definition, "name": entity_name})
+
+                self.conversation.type(
+                    "Reference table created and stored in last memory. What's next?\n"
+                )
+                self.conversation.newline()
+
+                exit(1)
+
+        with open(self.get_default_table_template_path()) as f:
+            return Template(f.read()).substitute({"entity_name": entity_name})

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

@@ -3,6 +3,7 @@ import sys
 import gibson.core.Colors as Colors
 from gibson.api.Cli import Cli
 from gibson.command.BaseCommand import BaseCommand
+from gibson.core.Spinner import Spinner
 from gibson.core.TimeKeeper import TimeKeeper
 from gibson.dev.Dev import Dev
 
@@ -20,17 +21,18 @@ class Model(BaseCommand):
 
         time_keeper = TimeKeeper()
 
-        cli = Cli(self.configuration)
-        response = cli.code_models([entity["name"]])
-
-        Dev(self.configuration).model(
-            response["code"][0]["entity"]["name"], response["code"][0]["definition"]
-        )
+        with Spinner("Gibson is writing the models...", "Models written"):
+            cli = Cli(self.configuration)
+            response = cli.code_models([entity["name"]])
+            Dev(self.configuration).model(
+                response["code"][0]["entity"]["name"], response["code"][0]["definition"]
+            )
 
         if self.configuration.project.dev.active is True:
             self.conversation.type(
-                f"Gibson wrote the following {Colors.argument('model')} code to your project:\n"
+                f"\nGibson wrote the following {Colors.argument('model')} code to your project:\n"
             )
 
-        print(response["code"][0]["definition"])
-        time_keeper.display()
+        if not self.conversation.muted():
+            print(response["code"][0]["definition"])
+            time_keeper.display()

{gibson_cli-0.7.3 → gibson_cli-0.7.5}/gibson/command/code/Schema.py

@@ -3,6 +3,7 @@ import sys
 import gibson.core.Colors as Colors
 from gibson.api.Cli import Cli
 from gibson.command.BaseCommand import BaseCommand
+from gibson.core.Spinner import Spinner
 from gibson.core.TimeKeeper import TimeKeeper
 from gibson.dev.Dev import Dev
 
@@ -20,17 +21,18 @@ class Schema(BaseCommand):
 
         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"]
-        )
+        with Spinner("Gibson is writing the schemas...", "Schemas written"):
+            cli = Cli(self.configuration)
+            response = cli.code_schemas([entity["name"]])
+            Dev(self.configuration).schema(
+                response["code"][0]["entity"]["name"], response["code"][0]["definition"]
+            )
 
         if self.configuration.project.dev.active is True:
             self.conversation.type(
-                f"Gibson wrote the following {Colors.argument('schema')} code to your project:\n"
+                f"\nGibson wrote the following {Colors.argument('schema')} code to your project:\n"
             )
 
-        print(response["code"][0]["definition"])
-        time_keeper.display()
+        if not self.conversation.muted():
+            print(response["code"][0]["definition"])
+            time_keeper.display()

{gibson_cli-0.7.3 → gibson_cli-0.7.5}/gibson/command/code/Test.py

@@ -3,6 +3,7 @@ import sys
 import gibson.core.Colors as Colors
 from gibson.api.Cli import Cli
 from gibson.command.BaseCommand import BaseCommand
+from gibson.core.Spinner import Spinner
 from gibson.core.TimeKeeper import TimeKeeper
 from gibson.dev.Dev import Dev
 
@@ -20,17 +21,18 @@ class Test(BaseCommand):
 
         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"]
-        )
+        with Spinner("Gibson is writing the tests...", "Tests written"):
+            cli = Cli(self.configuration)
+            response = cli.code_testing([entity["name"]])
+            Dev(self.configuration).tests(
+                response["code"][0]["entity"]["name"], response["code"][0]["definition"]
+            )
 
         if self.configuration.project.dev.active is True:
             self.conversation.type(
-                f"Gibson wrote the following {Colors.argument('tests')} to your project:\n"
+                f"\nGibson wrote the following {Colors.argument('tests')} to your project:\n"
             )
 
-        print(response["code"][0]["definition"])
-        time_keeper.display()
+        if not self.conversation.muted():
+            print(response["code"][0]["definition"])
+            time_keeper.display()

{gibson_cli-0.7.3 → gibson_cli-0.7.5}/gibson/command/rewrite/Rewrite.py

@@ -25,7 +25,6 @@ class Rewrite(BaseCommand):
         super().__init__(configuration)
         self.wipe = wipe
         self.with_header = with_header
-        self.arguments = ["api", "base", "models", "schemas", "tests"]
 
     def execute(self):
         if len(sys.argv) == 2:

{gibson_cli-0.7.3 → gibson_cli-0.7.5}/gibson/core/Colors.py

@@ -1,4 +1,4 @@
-class Color:
+class Constants:
     BLACK = "\033[30m"
     BLACK_BG = "\033[40m"
     BLINK = "\033[5m"
@@ -42,17 +42,17 @@ class Color:
 
 # Colorize text with a given color
 def colorize(text, color):
-    return f"{color}{text}{Color.END}"
+    return f"{color}{text}{Constants.END}"
 
 
 # Colorize a command
 def command(text):
-    return colorize(text, Color.GREEN)
+    return green(text)
 
 
 # Colorize a subcommand
 def subcommand(text):
-    return colorize(text, Color.YELLOW)
+    return yellow(text)
 
 
 # Colorize an argument
@@ -67,27 +67,27 @@ def arguments(list):
 
 # Colorize user input
 def input(text):
-    return colorize(text, Color.WHITE2)
+    return white(text)
 
 
 # Colorize a command option
 def option(text):
-    return colorize(text, Color.CYAN)
+    return cyan(text)
 
 
 # Colorize a hint
 def hint(text):
-    return colorize(text, Color.GREY)
+    return grey(text)
 
 
 # Colorize a project name
 def project(text):
-    return colorize(text, Color.BOLD)
+    return bold(text)
 
 
 # Colorize a URL to appear as a link
 def link(text):
-    return colorize(colorize(text, Color.BLUE), Color.UNDERLINE)
+    return underline(blue(text))
 
 
 # Colorize the table name in a SQL statement
@@ -104,24 +104,44 @@ def model(code, name):
 
 # Colorize a time/duration output
 def time(text):
-    return colorize(text, Color.GREEN)
+    return green(text)
+
+
+def bold(text):
+    return colorize(text, Constants.BOLD)
+
+
+def underline(text):
+    return colorize(text, Constants.UNDERLINE)
+
+
+def blue(text):
+    return colorize(text, Constants.BLUE)
 
 
 def cyan(text):
-    return colorize(text, Color.CYAN)
+    return colorize(text, Constants.CYAN)
 
 
 def green(text):
-    return colorize(text, Color.GREEN)
+    return colorize(text, Constants.GREEN)
+
+
+def grey(text):
+    return colorize(text, Constants.GREY)
 
 
 def red(text):
-    return colorize(text, Color.RED)
+    return colorize(text, Constants.RED)
 
 
 def violet(text):
-    return colorize(text, Color.VIOLET)
+    return colorize(text, Constants.VIOLET)
+
+
+def white(text):
+    return colorize(text, Constants.WHITE2)
 
 
 def yellow(text):
-    return colorize(text, Color.YELLOW)
+    return colorize(text, Constants.YELLOW)

{gibson_cli-0.7.3 → gibson_cli-0.7.5}/gibson/core/Configuration.py

@@ -347,6 +347,7 @@ class Configuration:
             json.dump(data, f, indent=2)
 
     def set_config_paths(self):
+        config_path = os.environ.get("GIBSONAI_CONFIG_PATH", None)
         gibson_config_dir = ".gibsonai"
         user_home = os.environ.get("HOME")
         if user_home is None:
@@ -354,7 +355,7 @@ class Configuration:
                 "Gibson here. Please set your HOME environment variable."
             )
 
-        self.paths.top = f"{user_home}/{gibson_config_dir}"
+        self.paths.top = config_path or f"{user_home}/{gibson_config_dir}"
         self.paths.auth = f"{self.paths.top}/auth"
         self.paths.config = f"{self.paths.top}/config"
 

gibson_cli-0.7.5/gibson/core/Diff.py

@@ -0,0 +1,34 @@
+from difflib import Differ
+
+from gibson.core.Colors import green, red
+
+
+# Highlights all lines as additions with a green + at the beginning
+# This keeps visual clutter to a minimum when showing the diff of an entirely new entity
+def additions(input: str):
+    lines = input.splitlines(keepends=True)
+    result = []
+    for line in lines:
+        result.append(f"{green('+')} {line}")
+    return "".join(result)
+
+
+# Highlights the diffs between two strings, showing the additions and removals as distinct colored lines
+def diff(original: str, modified: str):
+    diffs = list(
+        Differ().compare(
+            original.splitlines(keepends=True), modified.splitlines(keepends=True)
+        )
+    )
+
+    result = []
+    for line in diffs:
+        if line.startswith("+ "):
+            result.append(green(line))
+        elif line.startswith("- "):
+            result.append(red(line))
+        elif line.startswith("  "):
+            result.append(line)
+        # Ignore lines starting with '? ' as they are not needed for this highlighting
+
+    return "".join(result)

gibson_cli-0.7.5/gibson/core/Spinner.py

@@ -0,0 +1,37 @@
+from yaspin import yaspin
+from yaspin.spinners import Spinners
+
+
+class Spinner:
+    def __init__(
+        self, start_text, success_text=None, fail_text=None, disappearing=False
+    ):
+        self.success_text = success_text or start_text
+        self.fail_text = fail_text or start_text
+        self.disappearing = disappearing
+        self.spinner = yaspin(
+            Spinners.binary,
+            text=start_text,
+            color="green",
+        )
+
+    def __enter__(self):
+        self.spinner.start()
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if exc_type is not None:
+            self.spinner.text = self.fail_text
+            self.spinner.fail("❌")
+        elif self.disappearing:
+            self.spinner.text = ""
+            self.spinner.stop()
+        else:
+            self.spinner.text = self.success_text
+            self.spinner.ok("✅")
+
+        self.spinner.stop()
+
+
+class ComputingSpinner(Spinner):
+    def __init__(self):
+        super().__init__("Gibson is computing...", disappearing=True)

gibson_cli-0.7.5/gibson/display/Header.py

@@ -0,0 +1,11 @@
+import math
+
+from gibson.core.Colors import bold
+
+
+class Header:
+    def render(self, text, colorizer=None):
+        output = text if colorizer is None else colorizer(text)
+        half = math.floor((78 - len(text)) / 2)  # 80 line length - 2 spaces
+        header = "/" * half + f" {bold(output)} " + "/" * half
+        return header

{gibson_cli-0.7.3 → gibson_cli-0.7.5}/gibson/display/WorkspaceFooter.py

@@ -4,9 +4,9 @@ import gibson.core.Colors as Colors
 class WorkspaceFooter:
     def render(self):
         return (
-            "=" * 79
+            "-" * 79
             + "\n"
-            + f"[{Colors.red(':q')} + enter = {Colors.red('discard')} changes] "
+            + f"[{Colors.red(':q')} + enter = {Colors.red('discard')} changes]        "
             + f"[{Colors.green(':wq')} + enter = {Colors.green('save')} changes + write code]\n\n"
-            + "Using natural language, tell me how I can modify this entity."
+            + "Using natural language, tell me how I can modify this entity:"
         )

{gibson_cli-0.7.3 → gibson_cli-0.7.5}/gibson/display/WorkspaceHeader.py

@@ -5,7 +5,7 @@ class WorkspaceHeader:
     def render(self, project_name):
         return (
             f"Project {project_name}".ljust(50)
-            + " " * 12
-            + "[PAIR PROGRAMMER]\n"
-            + "=" * 79
+            + " " * 14
+            + f"{Colors.bold('PAIR PROGRAMMER')}\n"
+            + "-" * 79
         ).replace(project_name, Colors.project(project_name))