gibson-cli 0.8.9__tar.gz → 0.8.11__tar.gz

{gibson_cli-0.8.9 → gibson_cli-0.8.11}/.gitignore

@@ -6,5 +6,6 @@ __pycache__
 .tox
 *.egg-info
 venv
+.venv
 dist
 build

{gibson_cli-0.8.9/gibson_cli.egg-info → gibson_cli-0.8.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gibson-cli
-Version: 0.8.9
+Version: 0.8.11
 Summary: Gibson Command Line Interface
 Author-email: GibsonAI <noc@gibsonai.com>
 Project-URL: Homepage, https://gibsonai.com/
@@ -27,6 +27,8 @@ Requires-Dist: faker-sqlalchemy==0.10.2208140
 Requires-Dist: fastapi==0.115.12
 Requires-Dist: fastapi-cli==0.0.2
 Requires-Dist: h11==0.14.0
+Requires-Dist: harlequin==2.1.2
+Requires-Dist: harlequin-mysql==1.1.0
 Requires-Dist: httpcore==1.0.5
 Requires-Dist: httptools==0.6.4
 Requires-Dist: httpx==0.27.0
@@ -60,7 +62,7 @@ Requires-Dist: sniffio==1.3.1
 Requires-Dist: sqlalchemy==1.4.41
 Requires-Dist: sse-starlette==2.2.1
 Requires-Dist: starlette==0.46.1
-Requires-Dist: textual==0.83.0
+Requires-Dist: textual==0.89.1
 Requires-Dist: tomli==2.0.1
 Requires-Dist: typer==0.12.3
 Requires-Dist: typing-extensions==4.13.0
@@ -72,7 +74,7 @@ Requires-Dist: watchfiles==1.0.5
 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/)
+[![GibsonAI](https://github.com/user-attachments/assets/5d5fd577-c19b-4110-b601-e7f20a3370c8)](https://gibsonai.com/)
 
 # Gibson CLI
 

{gibson_cli-0.8.9 → gibson_cli-0.8.11}/README.md

@@ -1,4 +1,4 @@
-[![GibsonAI](https://github.com/user-attachments/assets/26bc1002-f878-4995-a6c5-eb8d5eb69c28)](https://gibsonai.com/)
+[![GibsonAI](https://github.com/user-attachments/assets/5d5fd577-c19b-4110-b601-e7f20a3370c8)](https://gibsonai.com/)
 
 # Gibson CLI
 

{gibson_cli-0.8.9 → gibson_cli-0.8.11}/gibson/api/ProjectApi.py

@@ -1,3 +1,5 @@
+from typing import List
+
 from gibson.api.BaseApi import BaseApi
 from gibson.core.Configuration import Configuration
 
@@ -20,8 +22,13 @@ class ProjectApi(BaseApi):
     def lookup(self, uuid: str):
         return self.get(f"{uuid}")
 
-    def deploy(self, uuid: str):
-        return self.post(f"{uuid}/deploy")
+    def deploy(self, uuid: str, databases: List[str] | None = None):
+        return self.post(
+            f"{uuid}/deploy", {"environments": databases} if databases else None
+        )
+
+    def diff(self, uuid: str):
+        return self.get(f"{uuid}/diff")
 
     def mcp(self, uuid: str):
         return self.get(f"{uuid}/mcp")

gibson_cli-0.8.11/gibson/command/Deploy.py

@@ -0,0 +1,52 @@
+from rich.prompt import Confirm
+
+from gibson.api.ProjectApi import ProjectApi
+from gibson.command.BaseCommand import BaseCommand
+from gibson.core.Select import MultiSelect
+from gibson.core.Spinner import Spinner
+
+
+class Deploy(BaseCommand):
+    def execute(self):
+        self.configuration.require_login()
+        project_id = self.configuration.require_project_id()
+        project = ProjectApi(self.configuration).lookup(project_id)
+        databases = [database["environment"] for database in project["databases"]]
+
+        selected = MultiSelect(
+            title="Select the database(s) to deploy",
+            options=databases,
+        ).prompt()
+
+        if not selected:
+            self.conversation.type("No database selected\n")
+            exit(1)
+
+        for database in selected:
+            diff = ProjectApi(self.configuration).diff(project_id)
+            if diff:
+                self.conversation.type(f"\nDiff for {database} database:\n\n")
+                self.conversation.type(diff)
+                self.conversation.newline()
+
+                if Confirm.ask(
+                    f"After reviewing the diff, are you sure you want to deploy the {database} database?"
+                ):
+                    self.conversation.newline()
+                    with Spinner(
+                        start_text=f"Deploying {database} database...",
+                        success_text=f"Deployed {database} database",
+                        fail_text=f"Deployment failed for {database} database",
+                    ):
+                        ProjectApi(self.configuration).deploy(
+                            project_id, databases=[database]
+                        )
+
+                else:
+                    self.conversation.type(
+                        f"\nSkipping deployment for {database} database\n",
+                    )
+            else:
+                self.conversation.type(
+                    f"\nNo changes to deploy for {database} database\n",
+                )

{gibson_cli-0.8.9 → gibson_cli-0.8.11}/gibson/command/Help.py

@@ -4,7 +4,6 @@ from rich.table import Table
 from rich.text import Text
 
 from gibson.command.BaseCommand import BaseCommand
-from gibson.core.Memory import Memory
 
 
 class Help(BaseCommand):
@@ -25,27 +24,26 @@ class Help(BaseCommand):
             "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",
+            },
+            "deploy": {
+                "description": "deploy the project database(s) with the current schema",
+                "subcommands": None,
             },
             "dev": {
                 "description": Text.assemble(
@@ -53,73 +51,55 @@ class Help(BaseCommand):
                     *dev_mode_text,
                 ),
                 "subcommands": ["on", "off"],
-                "memory": None,
-            },
-            "forget": {
-                "description": "delete entities from memory",
-                "subcommands": ["all", "last", "stored"],
-                "memory": "based on user selection",
             },
-            "help": {"description": "for help", "subcommands": None, "memory": None},
+            "help": {"description": "for help", "subcommands": 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,
             },
             "mcp": {
                 "description": "allows tools like Cursor to interact with your gibson project",
                 "subcommands": ["run"],
-                "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",
+            },
+            "studio": {
+                "description": "connect to your database and launch the SQL studio",
+                "subcommands": None,
             },
             "tree": {
                 "description": "illustrate the project layout in a tree view",
                 "subcommands": None,
-                "memory": None,
             },
             "q": {
-                "description": "ask gibson a question using natural language",
+                "description": "chat with gibson",
                 "subcommands": None,
-                "memory": None,
             },
         }
 
@@ -142,7 +122,6 @@ class Help(BaseCommand):
         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(
@@ -155,26 +134,8 @@ class Help(BaseCommand):
                     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.8.11/gibson/command/Studio.py

@@ -0,0 +1,58 @@
+from urllib.parse import urlparse
+
+from harlequin.app import Harlequin
+from harlequin.plugins import load_adapter_plugins
+
+from gibson.api.ProjectApi import ProjectApi
+from gibson.command.BaseCommand import BaseCommand
+from gibson.core.Select import Select
+from gibson.core.Spinner import DisappearingSpinner
+
+
+class Studio(BaseCommand):
+    def execute(self):
+        self.configuration.require_login()
+        project_id = self.configuration.require_project_id()
+
+        project = ProjectApi(self.configuration).lookup(project_id)
+
+        choices = [database["environment"] for database in project["databases"]]
+
+        selected = Select(
+            title="Select a database",
+            options=choices,
+        ).prompt()
+
+        if not selected:
+            self.conversation.type("No database selected\n")
+            exit(1)
+
+        database = next(
+            (db for db in project["databases"] if db["environment"] == selected), None
+        )
+
+        with DisappearingSpinner(
+            start_text=f"Connecting to {database['environment']} database...",
+            success_text=f"Connected to {database['environment']} database",
+            fail_text=f"Failed to connect to {database['environment']} database",
+        ):
+            plugins = load_adapter_plugins()
+            adapter = plugins[database["datastore_type"]]
+
+            if database["datastore_type"] == "mysql":
+                connection = urlparse(database["connection_string"])
+                adapter = adapter(
+                    conn_str=None,
+                    host=connection.hostname,
+                    port=connection.port,
+                    user=connection.username,
+                    password=connection.password,
+                    database=connection.path.lstrip("/"),
+                )
+            else:
+                raise ValueError(
+                    f"Unsupported database type: {database['datastore_type']}"
+                )
+
+            app = Harlequin(adapter=adapter)
+            app.run()

{gibson_cli-0.8.9 → gibson_cli-0.8.11}/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', 'install', args='--upgrade', inputs='gibson-cli')}\n"
+                f"Please update to the latest version by running: {Colors.command('uv', 'tool', args='install', inputs='gibson-cli@latest')}\n"
             )
         else:
             self.conversation.type(

{gibson_cli-0.8.9 → gibson_cli-0.8.11}/gibson/core/CommandRouter.py

@@ -5,13 +5,12 @@ from gibson.command.Build import Build
 from gibson.command.code.Code import Code
 from gibson.command.Conf import Conf
 from gibson.command.Count import Count
+from gibson.command.Deploy import Deploy
 from gibson.command.Dev import Dev
-from gibson.command.Forget import Forget
 from gibson.command.Help import Help
 from gibson.command.importer.Import import Import
 from gibson.command.list.List import List
 from gibson.command.mcp.McpServer import McpServer
-from gibson.command.Merge import Merge
 from gibson.command.Modify import Modify
 from gibson.command.new.New import New
 from gibson.command.Question import Question
@@ -19,6 +18,7 @@ from gibson.command.Remove import Remove
 from gibson.command.rename.Rename import Rename
 from gibson.command.rewrite.Rewrite import Rewrite
 from gibson.command.Show import Show
+from gibson.command.Studio import Studio
 from gibson.command.Tree import Tree
 from gibson.command.Version import Version
 from gibson.core.Configuration import Configuration
@@ -52,10 +52,10 @@ class CommandRouter:
             command = Conf(self.configuration)
         elif sys.argv[1] == "count":
             command = Count(self.configuration)
+        elif sys.argv[1] == "deploy":
+            command = Deploy(self.configuration)
         elif sys.argv[1] == "dev":
             command = Dev(self.configuration)
-        elif sys.argv[1] == "forget":
-            command = Forget(self.configuration)
         elif sys.argv[1] == "help":
             command = Help(self.configuration)
         elif sys.argv[1] == "import":
@@ -64,8 +64,6 @@ class CommandRouter:
             command = List(self.configuration)
         elif sys.argv[1] == "mcp":
             command = McpServer(self.configuration)
-        elif sys.argv[1] == "merge":
-            command = Merge(self.configuration)
         elif sys.argv[1] == "modify":
             command = Modify(self.configuration)
         elif sys.argv[1] == "new":
@@ -78,6 +76,8 @@ class CommandRouter:
             command = Rewrite(self.configuration, with_header=True)
         elif sys.argv[1] == "show":
             command = Show(self.configuration)
+        elif sys.argv[1] == "studio":
+            command = Studio(self.configuration)
         elif sys.argv[1] == "tree":
             command = Tree(self.configuration)
         elif sys.argv[1] in ["q"]:

{gibson_cli-0.8.9 → gibson_cli-0.8.11}/gibson/core/Configuration.py

@@ -237,6 +237,10 @@ class Configuration:
         return self.settings[self.project.name]
 
     def get_project_id(self):
+        project_id = os.getenv("GIBSONAI_PROJECT_ID")
+        if project_id:
+            return project_id
+
         self.require_project()
         return self.project.id
 

gibson_cli-0.8.11/gibson/core/Select.py

@@ -0,0 +1,270 @@
+from typing import Any, List, Optional
+
+import click
+from rich.align import Align
+from rich.console import Group
+from rich.live import Live
+from rich.panel import Panel
+from rich.text import Text
+
+
+class BaseSelect:
+    """Base class for select components with shared functionality."""
+
+    def __init__(
+        self,
+        options: List[str] = [],
+        title: str = "",
+        color: str = "bold magenta",
+        align: str = "left",
+        selection: str = "→",
+        highlight: str = "green",
+    ):
+        self.options = options
+        self.index = 0
+        self.title = title
+        self.color = color
+        self.align = align
+        self.selection = selection
+        self.highlight = highlight
+
+    def _get_click(self) -> Optional[str]:
+        match click.getchar():
+            case "\r":
+                return "enter"
+            case "\x1b[B" | "s" | "S" | "àP":
+                return "down"
+            case "\x1b[A" | "w" | "W" | "àH":
+                return "up"
+            case "\x1b[D" | "a" | "A" | "àK":
+                return "left"
+            case "\x1b[C" | "d" | "D" | "àM":
+                return "right"
+            case "\x1b":
+                return "exit"
+            case _:
+                return None
+
+    def _set_index(self, key: str) -> None:
+        if key == "down":
+            self.index += 1
+        elif key == "up":
+            self.index -= 1
+
+        if self.index > len(self.options) - 1:
+            self.index = 0
+        elif self.index < 0:
+            self.index = len(self.options) - 1
+
+    def _clear(self) -> None:
+        for _ in range(len(self.options) + 5):
+            print("\x1b[A\x1b[K", end="")
+
+    @property
+    def _usage_info(self) -> Text:
+        """Return usage information text for the select menu."""
+        return Text("Use ↑/↓ to navigate, ENTER to submit", "dim")
+
+    @property
+    def _layout(self) -> Group:
+        """Generate the display group for the menu.
+        This method should be overridden by subclasses.
+        """
+        raise NotImplementedError("Subclasses must implement _layout")
+
+    @property
+    def _panel_width(self) -> int:
+        """Return the width of the panel."""
+        # Calculate minimum width needed for the usage text
+        usage_width = len(self._usage_info.plain) + 2
+        # Get the max width of options
+        options_width = (
+            max((len(option) for option in self.options), default=0) + 5
+        )  # +5 for marker and spacing
+        # Use the larger of the two widths, plus some padding
+        return max(usage_width, options_width) + 4
+
+    def prompt(self) -> Any:
+        """Display the menu and handle user input.
+        This method should be overridden by subclasses.
+        """
+        raise NotImplementedError("Subclasses must implement prompt")
+
+
+class Select(BaseSelect):
+    def __init__(
+        self,
+        options: List[str] = [],
+        start_index: int = 0,
+        title: str = "",
+        color: str = "bold magenta",
+        align: str = "left",
+        selection: str = "→",
+        highlight: str = "green",
+    ):
+        super().__init__(
+            options=options,
+            title=title,
+            color=color,
+            align=align,
+            selection=selection,
+            highlight=highlight,
+        )
+        self.index = start_index
+
+    @property
+    def _layout(self) -> Group:
+        menu = Text(justify="left")
+
+        selected = Text(self.selection + " ", self.highlight)
+        not_selected = Text(" " * (len(self.selection) + 1))
+
+        for idx, option in enumerate(self.options):
+            if idx == self.index:
+                menu.append(
+                    Text.assemble(selected, Text(option + "\n", self.highlight))
+                )
+            else:
+                menu.append(Text.assemble(not_selected, option + "\n"))
+
+        menu.rstrip()
+
+        menu = Panel(menu, padding=1, width=self._panel_width)
+        menu.title = Text(self.title, self.color)
+        menu.subtitle = self._usage_info
+
+        return Group(Align(menu, self.align))
+
+    def prompt(self) -> str:
+        with Live(self._layout, auto_refresh=False, screen=False) as live:
+            live.update(self._layout, refresh=True)
+            while True:
+                try:
+                    key = self._get_click()
+                    if key == "enter":
+                        break
+                    elif key == "exit":
+                        exit()
+
+                    self._set_index(key)
+                    live.update(self._layout, refresh=True)
+                except (KeyboardInterrupt, EOFError):
+                    exit()
+
+        self._clear()
+
+        return self.options[self.index]
+
+
+class MultiSelect(BaseSelect):
+    def __init__(
+        self,
+        options: List[str] = [],
+        start_indices: Optional[List[int]] = None,
+        title: str = "",
+        color: str = "bold magenta",
+        align: str = "left",
+        selection: str = "→",
+        highlight: str = "green",
+        selected_marker: str = "●",
+        unselected_marker: str = "○",
+    ):
+        super().__init__(
+            options=options,
+            title=title,
+            color=color,
+            align=align,
+            selection=selection,
+            highlight=highlight,
+        )
+        self.selected_indices = start_indices or []
+        self.selected_marker = selected_marker
+        self.unselected_marker = unselected_marker
+
+    def _get_click(self) -> Optional[str]:
+        # Override to add space key handling
+        match click.getchar():
+            case "\r":
+                return "enter"
+            case "\x1b[B" | "s" | "S" | "àP":
+                return "down"
+            case "\x1b[A" | "w" | "W" | "àH":
+                return "up"
+            case "\x1b[D" | "a" | "A" | "àK":
+                return "left"
+            case "\x1b[C" | "d" | "D" | "àM":
+                return "right"
+            case " ":
+                return "space"
+            case "\x1b":
+                return "exit"
+            case _:
+                return None
+
+    def _toggle_selection(self) -> None:
+        if self.index in self.selected_indices:
+            self.selected_indices.remove(self.index)
+        else:
+            self.selected_indices.append(self.index)
+
+    @property
+    def _usage_info(self) -> Text:
+        """Return usage information text for the multi-select menu."""
+        return Text("Use ↑/↓ to navigate, SPACE to toggle, ENTER to submit", "dim")
+
+    @property
+    def _layout(self) -> Group:
+        menu = Text(justify="left")
+
+        cursor_selected = Text(self.selection + " ", self.highlight)
+        cursor_not_selected = Text(" " * (len(self.selection) + 1))
+
+        for idx, option in enumerate(self.options):
+            # Determine if this option is selected
+            marker = (
+                self.selected_marker
+                if idx in self.selected_indices
+                else self.unselected_marker
+            )
+
+            # Determine if cursor is on this item
+            if idx == self.index:
+                menu.append(
+                    Text.assemble(
+                        cursor_selected, Text(f"{marker} {option}\n", self.highlight)
+                    )
+                )
+            else:
+                menu.append(Text.assemble(cursor_not_selected, f"{marker} {option}\n"))
+
+        menu.rstrip()
+
+        menu = Panel(menu, padding=1, width=self._panel_width)
+        menu.title = Text(self.title, self.color)
+        menu.subtitle = self._usage_info
+
+        return Group(Align(menu, self.align))
+
+    def prompt(self) -> List[str]:
+        with Live(self._layout, auto_refresh=False, screen=False) as live:
+            live.update(self._layout, refresh=True)
+            while True:
+                try:
+                    key = self._get_click()
+                    if key == "enter":
+                        break
+                    elif key == "exit":
+                        exit()
+                    elif key == "space":
+                        self._toggle_selection()
+                        live.update(self._layout, refresh=True)
+                    else:
+                        self._set_index(key)
+                        live.update(self._layout, refresh=True)
+                except (KeyboardInterrupt, EOFError):
+                    exit()
+
+        self._clear()
+
+        # Return the selected options
+        return [self.options[i] for i in self.selected_indices]