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

{gibson_cli-0.7.4/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.4
+Version: 0.7.5
 Summary: Gibson Command Line Interface
 Author-email: GibsonAI <noc@gibsonai.com>
 Project-URL: Homepage, https://gibsonai.com/

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

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import os
 import sys
 from string import Template
@@ -10,6 +12,7 @@ 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
@@ -60,34 +63,15 @@ class Entity(BaseCommand):
 
         return True
 
-    def configure_definition(self):
-        existing_entity = self.memory.recall_entity(sys.argv[3])
-        if existing_entity is not None:
-            return existing_entity["definition"]
-
-        parts = sys.argv[3].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": sys.argv[3]})
-
-                self.memory.append_last({"definition": definition, "name": sys.argv[3]})
-
-                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": sys.argv[3]})
-
     def execute(self):
         cli = Cli(self.configuration)
-
-        self.configuration.require_project()
-        definition = self.configure_definition()
+        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(
@@ -104,10 +88,19 @@ class Entity(BaseCommand):
                 .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(entity, data["code"][0]["definition"])
+                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()
@@ -185,8 +178,24 @@ class Entity(BaseCommand):
             + "/default-table.tmpl"
         )
 
-    def __render_workspace(self, entity: StructureEntity, model):
+    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))
@@ -194,11 +203,29 @@ class Entity(BaseCommand):
         print("")
         print(Header().render("SQL", Colors.cyan))
         print("")
-        print(Colors.table(entity.create_statement(), entity.name))
+        print(Colors.table(create_table_statement_diff, entity.name))
 
         print("")
         print(Header().render("Model", Colors.yellow))
         print("")
-        print(Colors.model(model, entity.name))
-
+        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.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.4 → gibson_cli-0.7.5}/gibson/display/Header.py

@@ -1,9 +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" {output} " + "/" * half
+        header = "/" * half + f" {bold(output)} " + "/" * half
         return header

{gibson_cli-0.7.4 → 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"
+            + " " * 14
+            + f"{Colors.bold('PAIR PROGRAMMER')}\n"
             + "-" * 79
         ).replace(project_name, Colors.project(project_name))

{gibson_cli-0.7.4 → gibson_cli-0.7.5}/gibson/display/tests/test_display_Header.py

@@ -5,8 +5,8 @@ from gibson.display.Header import Header
 def test_render():
     text = "abc def ghi"
     assert Header().render(text) == (
-        "///////////////////////////////// abc def ghi /////////////////////////////////"
+        f"///////////////////////////////// {Colors.bold(text)} /////////////////////////////////"
     )
     assert Header().render(text, Colors.red) == (
-        f"///////////////////////////////// {Colors.red(text)} /////////////////////////////////"
+        f"///////////////////////////////// {Colors.bold(Colors.red(text))} /////////////////////////////////"
     )

{gibson_cli-0.7.4 → gibson_cli-0.7.5}/gibson/display/tests/test_display_WorkspaceHeader.py

@@ -4,6 +4,6 @@ from gibson.display.WorkspaceHeader import WorkspaceHeader
 
 def test_render():
     assert WorkspaceHeader().render("abc def ghi") == (
-        f"""Project {Colors.project("abc def ghi")}                                           [PAIR PROGRAMMER]
+        f"""Project {Colors.project("abc def ghi")}                                             {Colors.bold("PAIR PROGRAMMER")}
 -------------------------------------------------------------------------------"""
     )

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gibson-cli
-Version: 0.7.4
+Version: 0.7.5
 Summary: Gibson Command Line Interface
 Author-email: GibsonAI <noc@gibsonai.com>
 Project-URL: Homepage, https://gibsonai.com/

{gibson_cli-0.7.4 → gibson_cli-0.7.5}/gibson_cli.egg-info/SOURCES.txt

@@ -74,6 +74,7 @@ gibson/core/CommandRouter.py
 gibson/core/Completions.py
 gibson/core/Configuration.py
 gibson/core/Conversation.py
+gibson/core/Diff.py
 gibson/core/Env.py
 gibson/core/Memory.py
 gibson/core/PythonPath.py

{gibson_cli-0.7.4 → gibson_cli-0.7.5}/pyproject.toml

@@ -15,7 +15,7 @@ classifiers = [
   "Intended Audience :: Developers",
   "Programming Language :: Python :: 3.9",
 ]
-version = "0.7.4"
+version = "0.7.5"
 
 [tool.setuptools.packages.find]
 where = ["."]