gibson-cli 0.6.1__py3-none-any.whl → 0.7.0__py3-none-any.whl

gibson/api/BaseApi.py

@@ -1,4 +1,5 @@
 import os
+import pprint
 
 import requests
 
@@ -96,7 +97,7 @@ class BaseApi:
                 message = r.json()
                 print("=" * 78)
                 print("Raw Response:\n")
-                print(message)
+                pprint.pprint(message)
                 print("\n" + "=" * 78)
             except requests.exceptions.JSONDecodeError:
                 pass

gibson/api/Cli.py

@@ -66,7 +66,10 @@ class Cli(BaseApi):
 
     def headers(self):
         headers = super().headers()
-        headers["X-Gibson-API-Key"] = self.configuration.project.api.key
+        if self.configuration.project.id:
+            headers["X-Gibson-Project-ID"] = self.configuration.project.id
+        else:
+            headers["X-Gibson-API-Key"] = self.configuration.project.api.key
         return headers
 
     def import_(self):
@@ -157,7 +160,11 @@ class Cli(BaseApi):
     def modeler_openapi(self, modeler_version, contents):
         r = self.post(
             "modeler/openapi",
-            {"contents": contents, "modeler": {"version": modeler_version}},
+            {
+                "contents": contents,
+                "datastore": {"type": self.configuration.project.datastore.type},
+                "modeler": {"version": modeler_version},
+            },
         )
 
         return r.json()

gibson/command/Build.py

@@ -1,5 +1,6 @@
 import sys
 
+import sqlalchemy
 from sqlalchemy import create_engine
 from sqlalchemy.orm import sessionmaker
 
@@ -18,11 +19,19 @@ class Build(BaseCommand):
 
         self.conversation.type("Connected to datastore...\n")
 
+        if self.configuration.project.datastore.type == "mysql":
+            self.__build_mysql(session)
+        elif self.configuration.project.datastore.type == "postgresql":
+            self.__build_postgresql(session)
+
+        self.conversation.newline()
+
+    def __build_mysql(self, session):
         try:
-            if self.configuration.project.datastore.type == "mysql":
-                table_exceptions = TableExceptions().mysql()
-                session.execute("set foreign_key_checks = 0")
-                self.conversation.type("  foreign key checks have been disabled\n")
+            table_exceptions = TableExceptions().mysql()
+
+            session.execute("set foreign_key_checks = 0")
+            self.conversation.type("  foreign key checks have been disabled\n")
 
             tables = session.execute("show tables").all()
             if len(tables) > 0:
@@ -39,11 +48,54 @@ class Build(BaseCommand):
                 self.conversation.type(f"    {entity['name']}\n", delay=0.002)
                 session.execute(entity["definition"])
         finally:
-            if self.configuration.project.datastore.type == "mysql":
-                session.execute("set foreign_key_checks = 1")
-                self.conversation.type("  foreign key checks have been enabled\n")
+            session.execute("set foreign_key_checks = 1")
+            self.conversation.type("  foreign key checks have been enabled\n")
+
+    def __build_postgresql(self, session):
+        table_exceptions = TableExceptions().postgresql()
+
+        schema = list(session.execute("select current_schema()"))[0][0]
+        self.conversation.type(f"  current schema is {schema}\n")
+
+        tables = list(
+            session.execute(
+                """select table_name
+                     from information_schema.tables
+                    where table_schema = :table_schema""",
+                {"table_schema": schema},
+            )
+        )
 
-        self.conversation.newline()
+        if len(tables) > 0:
+            self.conversation.type("  dropping existing entities\n")
+
+            for table in tables:
+                self.conversation.type(f"    {table[0]}\n", delay=0.002)
+                session.execute(f"drop table if exists {schema}.{table[0]} cascade")
+                session.commit()
+
+        self.conversation.type("  building entities\n")
+
+        tables = {}
+        for entity in self.memory.entities:
+            tables[entity["name"]] = entity["definition"]
+
+        while tables != {}:
+            remove = []
+            for name, definition in tables.items():
+
+                try:
+                    session.execute(definition)
+                    session.commit()
+
+                    self.conversation.type(f'    {name.split(".")[-1]}\n', delay=0.002)
+
+                    remove.append(name)
+                except sqlalchemy.exc.ProgrammingError:
+                    session.rollback()
+
+            for name in remove:
+                del tables[name]
 
     def execute(self):
         if len(sys.argv) != 3 or sys.argv[2] != "datastore":

gibson/command/Help.py

@@ -48,10 +48,6 @@ class Help(BaseCommand):
                 "description": "move last changes into project",
                 "memory": "last -> stored",
             },
-            "model": {
-                "description": "write the model code for an entity",
-                "memory": "stored",
-            },
             "modify": {
                 "description": "change an entity using natural language",
                 "memory": "last > stored",
@@ -69,15 +65,7 @@ class Help(BaseCommand):
                 "description": "rewrite code",
                 "memory": "stored",
             },
-            "schema": {
-                "description": "write the schema code for an entity",
-                "memory": "stored",
-            },
             "show": {"description": "display an entity", "memory": "last > stored"},
-            "test": {
-                "description": "write the unit tests for an entity",
-                "memory": "stored",
-            },
             "tree": {"description": "illustrate the project layout", "memory": None},
             "q": {"description": "ask Gibson a question", "memory": None},
         }

gibson/command/Question.py

@@ -28,7 +28,10 @@ class Question(BaseCommand):
                     with open(path, "r") as f:
                         contents = f.read()
                 except FileNotFoundError:
-                    self.__file_not_found(path)
+                    self.configuration.display_project()
+                    self.conversation.file_not_found(path)
+                    self.conversation.newline()
+                    exit(1)
 
                 has_file = True
                 instructions += f"\n\n{contents}\n\n"
@@ -81,12 +84,6 @@ class Question(BaseCommand):
 
         self.conversation.newline()
 
-    def __file_not_found(self, path):
-        self.configuration.display_project()
-        self.conversation.type(f'404, My Friend. Cannot find file "{path}".\n')
-        self.conversation.newline()
-        exit(1)
-
     def __python_import_not_found(self, import_):
         self.configuration.display_project()
         self.conversation.type(f'That\'s a misfire, "{import_}" does not exist.\n')

gibson/command/code/Code.py

@@ -2,41 +2,71 @@ import sys
 
 import gibson.core.Colors as Colors
 from gibson.command.BaseCommand import BaseCommand
-from gibson.command.code.Entity import CodeEntity
-from gibson.command.code.Model import CodeModel
-from gibson.command.code.Schema import CodeSchema
-from gibson.command.code.Tests import CodeTests
+from gibson.command.code.Api import Api as CodeApi
+from gibson.command.code.Base import Base as CodeBase
+from gibson.command.code.Entity import Entity as CodeEntity
+from gibson.command.code.Model import Model as CodeModel
+from gibson.command.code.Models import Models as CodeModels
+from gibson.command.code.Schema import Schema as CodeSchema
+from gibson.command.code.Schemas import Schemas as CodeSchemas
+from gibson.command.code.Test import Test as CodeTest
+from gibson.command.code.Tests import Tests as CodeTests
 
 
 class Code(BaseCommand):
     def execute(self):
-        if len(sys.argv) == 4 and sys.argv[2] == "entity":
+        if len(sys.argv) == 3 and sys.argv[2] == "api":
+            CodeApi(self.configuration).execute()
+        elif len(sys.argv) == 3 and sys.argv[2] == "base":
+            CodeBase(self.configuration).execute()
+        elif len(sys.argv) == 4 and sys.argv[2] == "entity":
             CodeEntity(self.configuration).execute()
-        elif len(sys.argv) == 4 and sys.argv[2] == "model":
+        elif len(sys.argv) == 3 and sys.argv[2] == "models":
+            CodeModels(self.configuration).execute()
+        elif len(sys.argv) == 4 and sys.argv[2] == "models":
             CodeModel(self.configuration).execute()
-        elif len(sys.argv) == 4 and sys.argv[2] == "schema":
+        elif len(sys.argv) == 3 and sys.argv[2] == "schemas":
+            CodeSchemas(self.configuration).execute()
+        elif len(sys.argv) == 4 and sys.argv[2] == "schemas":
             CodeSchema(self.configuration).execute()
-        elif len(sys.argv) == 4 and sys.argv[2] == "tests":
+        elif len(sys.argv) == 3 and sys.argv[2] == "tests":
             CodeTests(self.configuration).execute()
+        elif len(sys.argv) == 4 and sys.argv[2] == "tests":
+            CodeTest(self.configuration).execute()
         else:
             self.usage()
 
     def usage(self):
         self.configuration.display_project()
         self.conversation.type(
-            f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('code')} {Colors.arguments(['entity', 'model', 'schema', 'tests'])} {Colors.input('[entity name]')} {Colors.hint('write code')}\n"
+            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"
+        )
+        self.conversation.type(
+            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('code')} {Colors.argument('api')} {Colors.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"
         )
         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"
         )
         self.conversation.type(
-            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('code')} {Colors.argument('model')} {Colors.input('[entity name]')} {Colors.hint('generate the model code for an entity')}\n"
+            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('code')} {Colors.argument('models')} {Colors.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"
+        )
+        self.conversation.type(
+            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('code')} {Colors.argument('schemas')} {Colors.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"
         )
         self.conversation.type(
-            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('code')} {Colors.argument('schema')} {Colors.input('[entity name]')} {Colors.hint('generate the schema code for an entity')}\n"
+            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('code')} {Colors.argument('tests')} {Colors.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 an entity')}\n"
+            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"
         )
         self.conversation.newline()
         exit(1)

gibson/command/code/Entity.py

@@ -14,10 +14,10 @@ from gibson.display.WorkspaceHeader import WorkspaceHeader
 from gibson.services.code.context.schema.Manager import (
     Manager as CodeContextSchemaManager,
 )
-from gibson.structure.Entity import Entity
+from gibson.structure.Entity import Entity as StructureEntity
 
 
-class CodeEntity(BaseCommand):
+class Entity(BaseCommand):
     CODE_WRITER_ENTITY_MODIFIER_NOOP = ""
 
     def __init__(self, configuration: Configuration):
@@ -96,7 +96,11 @@ class CodeEntity(BaseCommand):
             definition,
             self.CODE_WRITER_ENTITY_MODIFIER_NOOP,
         )
-        entity = Entity().import_from_struct(data)
+        entity = (
+            StructureEntity()
+            .instantiate(self.configuration.project.datastore.type)
+            .import_from_struct(data)
+        )
 
         while True:
             self.__render_workspace(entity, data["code"][0]["definition"])
@@ -147,15 +151,29 @@ class CodeEntity(BaseCommand):
                     entity.create_statement(),
                     input_,
                 )
-                entity = Entity().import_from_struct(data)
+                entity = (
+                    StructureEntity()
+                    .instantiate(self.configuration.project.datastore.type)
+                    .import_from_struct(data)
+                )
 
     def get_default_ref_table_template_path(self):
-        return os.path.dirname(__file__) + "/../../data/default-ref-table.tmpl"
+        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/default-table.tmpl"
+        return (
+            os.path.dirname(__file__)
+            + "/../../data/"
+            + self.configuration.project.datastore.type
+            + "/default-table.tmpl"
+        )
 
-    def __render_workspace(self, entity: Entity, model):
+    def __render_workspace(self, entity: StructureEntity, model):
         self.configuration.platform.cmd_clear()
 
         print("")

gibson/command/code/Model.py

@@ -7,7 +7,7 @@ from gibson.core.TimeKeeper import TimeKeeper
 from gibson.dev.Dev import Dev
 
 
-class CodeModel(BaseCommand):
+class Model(BaseCommand):
     def execute(self):
         self.configuration.require_project()
         entity = self.memory.recall_stored_entity(sys.argv[3])

gibson/command/code/Schema.py

@@ -7,7 +7,7 @@ from gibson.core.TimeKeeper import TimeKeeper
 from gibson.dev.Dev import Dev
 
 
-class CodeSchema(BaseCommand):
+class Schema(BaseCommand):
     def execute(self):
         self.configuration.require_project()
         entity = self.memory.recall_stored_entity(sys.argv[3])

gibson/command/code/Test.py

@@ -0,0 +1,35 @@
+import sys
+
+import gibson.core.Colors as Colors
+from gibson.api.Cli import Cli
+from gibson.command.BaseCommand import BaseCommand
+from gibson.core.TimeKeeper import TimeKeeper
+from gibson.dev.Dev import Dev
+
+
+class Test(BaseCommand):
+    def execute(self):
+        self.configuration.require_project()
+        entity = self.memory.recall_stored_entity(sys.argv[3])
+        if entity is None:
+            self.conversation.not_sure_no_entity(
+                self.configuration.project.name, sys.argv[3]
+            )
+            exit(1)
+
+        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"]
+        )
+
+        if self.configuration.project.dev.active is True:
+            self.conversation.type(
+                f"Gibson wrote the following {Colors.argument('tests')} to your project:\n"
+            )
+
+        print(response["code"][0]["definition"])
+        time_keeper.display()

gibson/command/code/Tests.py

@@ -1,35 +1,26 @@
-import sys
-
-import gibson.core.Colors as Colors
 from gibson.api.Cli import Cli
 from gibson.command.BaseCommand import BaseCommand
 from gibson.core.TimeKeeper import TimeKeeper
 from gibson.dev.Dev import Dev
 
 
-class CodeTests(BaseCommand):
+class Tests(BaseCommand):
     def execute(self):
-        self.configuration.require_project()
-        entity = self.memory.recall_stored_entity(sys.argv[3])
-        if entity is None:
-            self.conversation.not_sure_no_entity(
-                self.configuration.project.name, sys.argv[3]
-            )
-            exit(1)
+        entities = []
+        if self.memory.entities is not None:
+            for entity in self.memory.entities:
+                entities.append(entity["name"])
 
         time_keeper = TimeKeeper()
 
         cli = Cli(self.configuration)
-        response = cli.code_testing([entity["name"]])
+        response = cli.code_testing(entities)
 
-        Dev(self.configuration).tests(
-            response["code"][0]["entity"]["name"], response["code"][0]["definition"]
-        )
+        for entry in response["code"]:
+            Dev(self.configuration).tests(entry["entity"]["name"], entry["definition"])
 
-        if self.configuration.project.dev.active is True:
-            self.conversation.type(
-                f"Gibson wrote the following {Colors.argument('tests')} to your project:\n"
-            )
+            if self.conversation.muted() is False:
+                print(entry["definition"])
 
-        print(response["code"][0]["definition"])
-        time_keeper.display()
+        if self.conversation.muted() is False:
+            time_keeper.display()

gibson/command/importer/Import.py

@@ -1,3 +1,4 @@
+import re
 import sys
 
 from sqlalchemy import create_engine
@@ -19,8 +20,11 @@ class Import(BaseCommand):
         if len(sys.argv) == 3 and sys.argv[2] == "api":
             entities = self.__import_from_api()
             write_code = self.configuration.project.dev.active
-        elif len(sys.argv) == 3 and sys.argv[2] == "datastore":
-            entities = self.__import_from_datastore()
+        elif len(sys.argv) == 3 and sys.argv[2] == "mysql":
+            entities = self.__import_from_mysql()()
+            write_code = self.configuration.project.dev.active
+        elif len(sys.argv) == 4 and sys.argv[2] == "pg_dump":
+            entities = self.__import_from_postgresql()
             write_code = self.configuration.project.dev.active
         elif len(sys.argv) == 4 and sys.argv[2] == "openapi":
             return OpenApi(self.configuration).execute()
@@ -31,7 +35,10 @@ class Import(BaseCommand):
 
         word_entities = "entity" if len(entities) == 1 else "entities"
 
-        self.conversation.type("\nSummary\n")
+        if len(entities) > 0:
+            self.conversation.newline()
+
+        self.conversation.type("Summary\n")
         self.conversation.type(f"    {len(entities)} {word_entities} imported\n")
         self.conversation.newline()
 
@@ -53,15 +60,11 @@ class Import(BaseCommand):
 
         return response["project"]["entities"]
 
-    def __import_from_datastore(self):
-        self.configuration.display_project()
-
+    def __import_from_mysql(self):
         db = create_engine(self.configuration.project.datastore.uri)
         session = sessionmaker(autocommit=False, autoflush=False, bind=db)()
 
-        table_exceptions = TableExceptions().universal()
-        if self.configuration.project.datastore.type == "mysql":
-            table_exceptions = TableExceptions().mysql()
+        table_exceptions = TableExceptions().mysql()
 
         self.conversation.type("Connected to datastore...\n")
         self.conversation.type("Building schema...\n")
@@ -83,6 +86,72 @@ class Import(BaseCommand):
 
         return entities
 
+    def __import_from_postgresql(self):
+        self.conversation.type("Reading pg_dump file...\n")
+
+        try:
+            with open(sys.argv[3], "r") as f:
+                contents = f.read()
+        except FileNotFoundError:
+            self.conversation.file_not_found(sys.argv[3])
+            self.conversation.newline()
+            exit(1)
+
+        lines = contents.split("\n")
+
+        tables = {}
+        for i in range(len(lines)):
+            matches = re.search(
+                r"^create table (.*)\s+\(", lines[i].lstrip().rstrip(), re.IGNORECASE
+            )
+            if matches:
+                table_name = matches[1].split(".")[-1]
+                definition = []
+
+                while True:
+                    i += 1
+
+                    if lines[i].lstrip().rstrip() == ");":
+                        tables[table_name] = definition
+                        break
+                    else:
+                        definition.append(lines[i].lstrip().rstrip())
+            else:
+                matches = re.search(
+                    r"^alter table(?:\s+only)\s+(.*)$",
+                    lines[i].lstrip().rstrip(),
+                    re.IGNORECASE,
+                )
+                if matches:
+                    table_name = matches[1].split(".")[-1]
+
+                    i += 1
+                    matches = re.search(
+                        r"^add (constraint .*?);?$",
+                        lines[i].lstrip().rstrip(),
+                        re.IGNORECASE,
+                    )
+                    if matches:
+                        if tables[table_name][-1][-1] != ",":
+                            tables[table_name][-1] += ","
+
+                        tables[table_name].append(matches[1] + ",")
+
+        entities = []
+        for table_name, definition in tables.items():
+            self.conversation.type(f"    {table_name}\n", delay=0.002)
+
+            definition[-1] = definition[-1].rstrip(",")
+
+            create_table = f"create table if not exists {table_name} (\n"
+            for entry in definition:
+                create_table += " " * 4 + entry + "\n"
+            create_table += ")"
+
+            entities.append({"definition": create_table, "name": table_name})
+
+        return entities
+
     def usage(self):
         self.configuration.display_project()
         datastore_uri = (
@@ -91,13 +160,16 @@ class Import(BaseCommand):
             else ""
         )
         self.conversation.type(
-            f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('import')} {Colors.arguments(['api', 'datastore', 'openapi'])} {Colors.hint('import entities')}\n"
+            f"usage: {Colors.command(self.configuration.command)} {Colors.subcommand('import')} {Colors.arguments(['api', 'mysql', 'pg_dump', 'openapi'])} {Colors.hint('import entities')}\n"
         )
         self.conversation.type(
             f"       {Colors.command(self.configuration.command)} {Colors.subcommand('import')} {Colors.argument('api')} {Colors.hint(f'import all entities from your project created on {Colors.link(self.configuration.app_domain())}')}\n"
         )
         self.conversation.type(
-            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('import')} {Colors.argument('datastore')} {Colors.hint('import all entities from your local datastore')} {Colors.link(datastore_uri)}\n"
+            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('import')} {Colors.argument('mysql')} {Colors.hint('import all entities from your MySQL database')} ({Colors.link(datastore_uri)})\n"
+        )
+        self.conversation.type(
+            f"       {Colors.command(self.configuration.command)} {Colors.subcommand('import')} {Colors.argument('pg_dump')} {Colors.input('path/to/pg_dump.sql')} {Colors.hint('import all entities from a pg_dump file')}\n"
         )
         self.conversation.type(
             f"       {Colors.command(self.configuration.command)} {Colors.subcommand('import')} {Colors.argument('openapi')} {Colors.input('path/to/openapi.json')} {Colors.hint('import all entities from an OpenAPI spec file')}\n"

gibson/command/importer/OpenApi.py

@@ -20,7 +20,10 @@ class OpenApi(BaseCommand):
             with open(sys.argv[3], "r") as f:
                 contents = json.loads(f.read())
         except FileNotFoundError:
-            self.file_not_found()
+            self.configuration.display_project()
+            self.conversation.file_not_found(sys.argv[3])
+            self.conversation.newline()
+            exit(1)
         except json.decoder.JSONDecodeError:
             self.bad_json()
 
@@ -112,14 +115,6 @@ class OpenApi(BaseCommand):
 
         return True
 
-    def file_not_found(self):
-        self.configuration.display_project()
-        self.conversation.type(
-            f'Well that embarrassing. There is no file "{sys.argv[3]}".\n'
-        )
-        self.conversation.newline()
-        exit(1)
-
     def unrecognized_format(self):
         self.configuration.display_project()
         self.conversation.type(

gibson/command/new/Module.py

@@ -3,7 +3,7 @@ from gibson.api.Cli import Cli
 from gibson.command.BaseCommand import BaseCommand
 
 
-class NewModule(BaseCommand):
+class Module(BaseCommand):
     def execute(self):
         self.configuration.require_project()
         module_name = self.conversation.prompt_module()

gibson/command/new/New.py

@@ -2,9 +2,9 @@ import sys
 
 import gibson.core.Colors as Colors
 from gibson.command.BaseCommand import BaseCommand
-from gibson.command.code.Entity import CodeEntity
-from gibson.command.new.Module import NewModule
-from gibson.command.new.Project import NewProject
+from gibson.command.code.Entity import Entity as CodeEntity
+from gibson.command.new.Module import Module as NewModule
+from gibson.command.new.Project import Project as NewProject
 
 
 class New(BaseCommand):

gibson/command/new/Project.py

@@ -1,7 +1,7 @@
 from gibson.command.BaseCommand import BaseCommand
 
 
-class NewProject(BaseCommand):
+class Project(BaseCommand):
     def execute(self):
         self.conversation.new_project(self.configuration)
         project_name = self.conversation.prompt_project()
@@ -9,7 +9,7 @@ class NewProject(BaseCommand):
             self.conversation.project_already_exists(project_name)
             exit(1)
 
-        project_description = self.conversation.prompt_description(project_name)
+        project_description = self.conversation.prompt_project_description(project_name)
 
         self.configuration.set_project_env(project_name)
         self.configuration.append_project_to_conf(project_name, project_description)