ntc-dev-kit 1.2.1__tar.gz → 1.3.0__tar.gz

{ntc_dev_kit-1.2.1/ntc_dev_kit.egg-info → ntc_dev_kit-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ntc-dev-kit
-Version: 1.2.1
+Version: 1.3.0
 Summary: Nexent Toolkit Console - A CLI tool for scaffolding Django REST Framework, React, Next.js, and Flutter projects
 Home-page: https://github.com/nexent/ntc
 Author: Nexent
@@ -27,6 +27,7 @@ License-File: LICENSE
 Requires-Dist: colorama>=0.4.6
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: textual>=0.47.0
+Requires-Dist: tomli>=2.0; python_version < "3.11"
 Provides-Extra: dev
 Requires-Dist: build>=1.0; extra == "dev"
 Requires-Dist: twine>=4.0; extra == "dev"
@@ -121,7 +122,85 @@ ntc init -t nextjs --name site --install --yes
 | `--with-auth` / `--no-auth` | Django: include the sign-in app (custom User model, JWT, migration included) |
 | `--env` | Django: `venv`, `conda`, `existing` (the active virtualenv) or `skip` |
 | `--install` / `--no-install` | Others: run `npm install` / `flutter pub get` |
-| `--yes`, `-y` | Ask nothing; needs `--name` and `--technology` |
+| `--apps` | A workspace instead of one app: `backend,website,dashboard,admin,mobile` (any of them) |
+| `--git` | Workspace: `per-app` (default), `single` or `none` |
+| `--yes`, `-y` | Ask nothing; needs `--name` and `--technology` (or `--apps`) |
+
+### Workspaces: several apps at once
+
+Tick more than one app at **What are you building?** (Space ticks) - say a backend, a website and
+an admin dashboard - and they're created side by side in one folder, already connected:
+
+- each app gets its own port, the frontends point at the backend's API, and the backend allows
+  the frontends' origins (CORS);
+- dependencies install for all apps at once, one line each;
+- git: a repository per app (plus a small one at the root for `ntc.toml`), one for everything,
+  or none;
+- `ntc.toml` at the root says how each app is set up and run.
+
+```
+kaya/
+├── ntc.toml        # the apps, their ports, setup and run commands, env
+├── README.md
+├── backend/        # Django REST API   http://127.0.0.1:8000
+├── website/        # Next.js           http://127.0.0.1:3000
+└── admin/          # React admin       http://127.0.0.1:5173
+```
+
+Then, from anywhere inside the workspace:
+
+```bash
+ntc start                  # every app in this terminal: a tab each plus "All"
+ntc start backend admin    # just these (and what they need)
+ntc start --plain          # interleaved output instead (CI, logs)
+ntc setup                  # environments, .env files, dependencies - after a clone or a deep clean
+ntc clean                  # build output and caches; shows the space freed
+ntc clean --deep           # also node_modules and Python environments
+ntc add                    # another app, wired in like the rest
+```
+
+In `ntc start`: **1-9** (or the tabs) switch app, **0** shows all, **r** restarts, **s** stops or
+starts, **o** opens it in the browser, **i** types into it (Flutter's `r` hot reload), **q** quits
+and stops everything. Apps wait for the ones they `need` (the backend) before starting, and a port
+that's already taken is reported instead of crashing.
+
+`ntc clean` only removes what the tools rebuild (`.next`, `dist`, `__pycache__`, caches; with
+`--deep` also `node_modules` and `env`), never anything git tracks, and skips apps that are running.
+`--dry-run` shows what would go.
+
+`ntc.toml` is plain TOML and meant to be edited and committed (no secrets in it - those stay in
+each app's `.env`):
+
+```toml
+name = "kaya"
+
+[apps.backend]
+kind = "django"
+path = "backend"
+port = 8000
+python = "env"
+setup = ["{python} -m pip install -r requirements-dev.txt", "{python} manage.py migrate"]
+run = "{python} manage.py runserver 127.0.0.1:{port}"
+# also = { worker = "{python} -m celery -A kaya worker -B -l INFO" }
+
+[apps.backend.env]
+CORS_ALLOWED_ORIGINS = "{frontends.origins}"
+
+[apps.website]
+kind = "nextjs"
+path = "website"
+port = 3000
+needs = ["backend"]
+run = "npm run dev -- --port {port}"
+repo = "git@github.com:you/website.git"   # `ntc setup` clones it when the folder is missing
+
+[apps.website.env]
+NEXT_PUBLIC_API_BASE_URL = "{backend.url}/api/v1"
+```
+
+Placeholders: `{port}`, `{url}`, `{python}` (this app's), `{<app>.port}`, `{<app>.url}`,
+`{frontends.origins}`. Commands are one program with its arguments (no `&&`), so they run the
+same on Windows and Unix.
 
 ### Technology Options
 

{ntc_dev_kit-1.2.1 → ntc_dev_kit-1.3.0}/README.md

@@ -81,7 +81,85 @@ ntc init -t nextjs --name site --install --yes
 | `--with-auth` / `--no-auth` | Django: include the sign-in app (custom User model, JWT, migration included) |
 | `--env` | Django: `venv`, `conda`, `existing` (the active virtualenv) or `skip` |
 | `--install` / `--no-install` | Others: run `npm install` / `flutter pub get` |
-| `--yes`, `-y` | Ask nothing; needs `--name` and `--technology` |
+| `--apps` | A workspace instead of one app: `backend,website,dashboard,admin,mobile` (any of them) |
+| `--git` | Workspace: `per-app` (default), `single` or `none` |
+| `--yes`, `-y` | Ask nothing; needs `--name` and `--technology` (or `--apps`) |
+
+### Workspaces: several apps at once
+
+Tick more than one app at **What are you building?** (Space ticks) - say a backend, a website and
+an admin dashboard - and they're created side by side in one folder, already connected:
+
+- each app gets its own port, the frontends point at the backend's API, and the backend allows
+  the frontends' origins (CORS);
+- dependencies install for all apps at once, one line each;
+- git: a repository per app (plus a small one at the root for `ntc.toml`), one for everything,
+  or none;
+- `ntc.toml` at the root says how each app is set up and run.
+
+```
+kaya/
+├── ntc.toml        # the apps, their ports, setup and run commands, env
+├── README.md
+├── backend/        # Django REST API   http://127.0.0.1:8000
+├── website/        # Next.js           http://127.0.0.1:3000
+└── admin/          # React admin       http://127.0.0.1:5173
+```
+
+Then, from anywhere inside the workspace:
+
+```bash
+ntc start                  # every app in this terminal: a tab each plus "All"
+ntc start backend admin    # just these (and what they need)
+ntc start --plain          # interleaved output instead (CI, logs)
+ntc setup                  # environments, .env files, dependencies - after a clone or a deep clean
+ntc clean                  # build output and caches; shows the space freed
+ntc clean --deep           # also node_modules and Python environments
+ntc add                    # another app, wired in like the rest
+```
+
+In `ntc start`: **1-9** (or the tabs) switch app, **0** shows all, **r** restarts, **s** stops or
+starts, **o** opens it in the browser, **i** types into it (Flutter's `r` hot reload), **q** quits
+and stops everything. Apps wait for the ones they `need` (the backend) before starting, and a port
+that's already taken is reported instead of crashing.
+
+`ntc clean` only removes what the tools rebuild (`.next`, `dist`, `__pycache__`, caches; with
+`--deep` also `node_modules` and `env`), never anything git tracks, and skips apps that are running.
+`--dry-run` shows what would go.
+
+`ntc.toml` is plain TOML and meant to be edited and committed (no secrets in it - those stay in
+each app's `.env`):
+
+```toml
+name = "kaya"
+
+[apps.backend]
+kind = "django"
+path = "backend"
+port = 8000
+python = "env"
+setup = ["{python} -m pip install -r requirements-dev.txt", "{python} manage.py migrate"]
+run = "{python} manage.py runserver 127.0.0.1:{port}"
+# also = { worker = "{python} -m celery -A kaya worker -B -l INFO" }
+
+[apps.backend.env]
+CORS_ALLOWED_ORIGINS = "{frontends.origins}"
+
+[apps.website]
+kind = "nextjs"
+path = "website"
+port = 3000
+needs = ["backend"]
+run = "npm run dev -- --port {port}"
+repo = "git@github.com:you/website.git"   # `ntc setup` clones it when the folder is missing
+
+[apps.website.env]
+NEXT_PUBLIC_API_BASE_URL = "{backend.url}/api/v1"
+```
+
+Placeholders: `{port}`, `{url}`, `{python}` (this app's), `{<app>.port}`, `{<app>.url}`,
+`{frontends.origins}`. Commands are one program with its arguments (no `&&`), so they run the
+same on Windows and Unix.
 
 ### Technology Options
 

{ntc_dev_kit-1.2.1 → ntc_dev_kit-1.3.0}/ntc/__init__.py

@@ -1,5 +1,5 @@
 """NTC - Nexent Toolkit Console."""
 
-__version__ = "1.2.1"
+__version__ = "1.3.0"
 __author__ = "Nexent"
 __license__ = "MIT"

{ntc_dev_kit-1.2.1 → ntc_dev_kit-1.3.0}/ntc/cli_enhanced.py

@@ -284,8 +284,10 @@ Examples:
   ntc init -t django --name shop-api --with-auth --env venv --yes
                                 # No questions at all (scripts, CI, AI agents)
   ntc init -t nextjs --name site --install --yes
-  ntc compose myproject         # Compose full-stack project with multiple components
-  ntc start                     # Start all services from ntc.yml configuration
+  ntc init --name shop --apps backend,website,admin --yes
+                                # A workspace: several apps wired together, plus ntc.toml
+  ntc start                     # Run the workspace's apps in this terminal
+  ntc setup / ntc clean / ntc add
   ntc create app myapp          # Create new Django app
   ntc drf init path name        # Legacy Django REST Framework initialization
         """
@@ -321,7 +323,11 @@ Examples:
                                help="Next.js/React/Flutter: don't install dependencies")
     init_parser.add_argument("--yes", "-y", action="store_true",
                              help="Don't ask: use the options given and defaults for the rest "
-                                  "(requires --name and --technology)")
+                                  "(requires --name and --technology or --apps)")
+    init_parser.add_argument("--apps", help="A workspace of several apps, comma-separated: "
+                                            "backend, website, dashboard, admin, mobile")
+    init_parser.add_argument("--git", choices=["per-app", "single", "none"],
+                             help="Workspace: a repository per app (default), one for everything, or none")
     
     # Create command for apps
     create_parser = subparsers.add_parser("create", help="Create new components")
@@ -345,13 +351,32 @@ Examples:
     drf_init_parser.add_argument("name", help="Project name")
     
     # Composer command for full-stack project composition
-    composer_parser = subparsers.add_parser("compose", help="Compose a full-stack project with multiple components")
-    composer_parser.add_argument("project_name", help="Name of the project")
-    composer_parser.add_argument("--path", help="Base path to create the project (default: current directory)")
+    subparsers.add_parser("compose", help="Replaced by `ntc init` (pick several apps)")
+    add_parser = subparsers.add_parser("add", help="Add apps to the workspace")
+    add_parser.add_argument("apps", nargs="*", help="backend, website, dashboard, admin, mobile")
+    add_parser.add_argument("--name", help="Folder name (when adding one app)")
+    add_parser.add_argument("--env", choices=["venv", "conda", "existing", "skip"], help="Backend: Python environment")
+    add_auth = add_parser.add_mutually_exclusive_group()
+    add_auth.add_argument("--with-auth", dest="with_auth", action="store_true", default=None)
+    add_auth.add_argument("--no-auth", dest="with_auth", action="store_false")
+    add_install = add_parser.add_mutually_exclusive_group()
+    add_install.add_argument("--install", dest="install", action="store_true", default=None)
+    add_install.add_argument("--no-install", dest="install", action="store_false")
+    add_parser.add_argument("--yes", "-y", action="store_true", help="Don't ask")
+    setup_parser = subparsers.add_parser("setup", help="Install the workspace's apps (after a clone or a deep clean)")
+    setup_parser.add_argument("apps", nargs="*", help="Only these apps")
+    clean_parser = subparsers.add_parser("clean", help="Delete build output and caches; say how much space it freed")
+    clean_parser.add_argument("apps", nargs="*", help="Only these apps")
+    clean_parser.add_argument("--deep", action="store_true",
+                              help="Also dependencies: node_modules, Python environments (`ntc setup` reinstalls)")
+    clean_parser.add_argument("--dry-run", action="store_true", help="Show what would go, delete nothing")
+    clean_parser.add_argument("--yes", "-y", action="store_true", help="Don't ask before deleting")
     
     # Start services command
-    start_parser = subparsers.add_parser("start", help="Start all services defined in ntc.yml")
-    start_parser.add_argument("--path", help="Path to project root directory (default: current directory)")
+    start_parser = subparsers.add_parser("start", help="Run the workspace's apps together in this terminal")
+    start_parser.add_argument("apps", nargs="*", help="Only these apps (and the ones they need)")
+    start_parser.add_argument("--plain", action="store_true",
+                              help="Interleaved output instead of the full-screen view (CI, logs)")
 
     # Doctor command for setup diagnostics
     doctor_parser = subparsers.add_parser("doctor", help="Check setup and fix common issues")
@@ -364,12 +389,20 @@ Examples:
     if args.command == "init":
         technology = args.technology or args.frontend or args.backend
         technology = {"drf": "django", "laravel": "django"}.get(technology, technology)
-        if args.yes and not (args.name and technology):
-            print_error("--yes needs --name and --technology, so there is nothing left to ask.")
+        apps = [a.strip() for a in args.apps.split(",") if a.strip()] if args.apps else None
+        if apps and technology:
+            print_error("Give either --technology (one app) or --apps (a workspace), not both.")
             sys.exit(2)
+        if args.yes and not (args.name and (technology or apps)):
+            print_error("--yes needs --name and --technology (or --apps), so there is nothing left to ask.")
+            sys.exit(2)
+        if apps and len(apps) == 1:
+            from ntc.workspace.config import ROLE_KINDS
+            technology, apps = ROLE_KINDS.get(apps[0], apps[0]), None
         from ntc.wizard import run as run_wizard
         created = run_wizard(technology=technology, name=args.name, path=args.path, with_auth=args.with_auth,
-                             env_choice=args.env, install=args.install, assume_yes=args.yes)
+                             env_choice=args.env, install=args.install, assume_yes=args.yes,
+                             apps=apps, git=args.git)
         sys.exit(0 if created else 1)
     elif args.command == "create" and args.create_type == "app":
         if not is_valid_project_name(args.app_name):
@@ -385,22 +418,23 @@ Examples:
         from ntc.templates.drf_structure.main import init_drf_project
         init_drf_project(args.path, args.name)
     elif args.command == "compose":
-        # Composer for full-stack project composition
-        if not is_valid_project_name(args.project_name):
-            print_error("Project name may only contain letters, numbers, underscores, and hyphens!")
-            sys.exit(1)
-        from ntc.composer.main import compose_project
-        if args.path:
-            compose_project(args.project_name, args.path)
-        else:
-            compose_project(args.project_name)
+        print_info("`ntc compose` is now part of `ntc init`: pick several apps (Space ticks them) and they're "
+                   "created together as a workspace, with an ntc.toml for `ntc start`.")
+        sys.exit(2)
     elif args.command == "start":
-        # Start services from ntc.yml configuration
-        from ntc.composer.main import start_services
-        if args.path:
-            start_services(args.path)
-        else:
-            start_services()
+        from ntc.workspace.start import run as run_start
+        sys.exit(0 if run_start(args.apps, plain=args.plain) else 1)
+    elif args.command == "setup":
+        from ntc.workspace.setup import run as run_setup
+        sys.exit(0 if run_setup(args.apps) else 1)
+    elif args.command == "clean":
+        from ntc.workspace.clean import run as run_clean
+        sys.exit(0 if run_clean(args.apps, deep=args.deep, assume_yes=args.yes, dry_run=args.dry_run) else 1)
+    elif args.command == "add":
+        from ntc.workspace.create import run_add
+        env_choice = {"existing": "active"}.get(args.env, args.env)
+        sys.exit(0 if run_add(args.apps, name=args.name, with_auth=args.with_auth, env_choice=env_choice,
+                              install=args.install, assume_yes=args.yes) else 1)
     elif args.command == "doctor":
         run_doctor()
     elif args.command == "tui":
@@ -412,6 +446,7 @@ Examples:
         print(f"\n  {Fore.LIGHTBLACK_EX}Quick Start:{Style.RESET_ALL}")
         print(f"  {Fore.WHITE}ntc tui{Style.RESET_ALL}               {Fore.LIGHTBLACK_EX}interactive terminal UI{Style.RESET_ALL}")
         print(f"  {Fore.WHITE}ntc init{Style.RESET_ALL}              {Fore.LIGHTBLACK_EX}interactive setup{Style.RESET_ALL}")
+        print(f"  {Fore.WHITE}ntc start{Style.RESET_ALL}             {Fore.LIGHTBLACK_EX}run a workspace's apps{Style.RESET_ALL}")
         print(f"  {Fore.WHITE}ntc init -t django{Style.RESET_ALL}    {Fore.LIGHTBLACK_EX}Django project{Style.RESET_ALL}")
         print(f"  {Fore.WHITE}ntc doctor{Style.RESET_ALL}            {Fore.LIGHTBLACK_EX}check setup{Style.RESET_ALL}")
         print()

{ntc_dev_kit-1.2.1 → ntc_dev_kit-1.3.0}/ntc/templates/drf_structure/main.py

@@ -373,6 +373,18 @@ def _render_project(project_root, project_name, original_name, with_auth):
     return True
 
 
+def write_env_file(project_root, project_name, original_name=None):
+    """Write the project's .env (development defaults, a new SECRET_KEY). It's gitignored, so a
+    fresh clone has none; `ntc setup` uses this to recreate it."""
+    structure_file = os.path.join(os.path.dirname(__file__), "structure.json")
+    with open(structure_file, "r", encoding="utf-8") as f:
+        template = json.load(f)[".env"]["template"]
+    variables = {"project_name": project_name, "original_name": original_name or project_name,
+                 "secret_key": secrets.token_urlsafe(50)}
+    with open(os.path.join(project_root, ".env"), "w", encoding="utf-8") as f:
+        f.write(get_template_content(template, variables))
+
+
 def init_drf_project(base_path, project_name, with_auth=False, env_choice=None):
     """Create a DRF project in base_path/<sanitized name> and set up its environment.
 

{ntc_dev_kit-1.2.1 → ntc_dev_kit-1.3.0}/ntc/utils/prompts.py

@@ -189,6 +189,82 @@ def text(question, default=None, validate=None):
             return value
 
 
+def multiselect(question, options, default=(), hint=None):
+    """Pick any of options: (label, value) or (label, value, description) tuples.
+
+    ↑/↓ move, Space (or the option's number) ticks/unticks, Enter confirms, Esc cancels.
+    Returns the ticked values in option order. Without a terminal: the defaults.
+    """
+    options = [opt if len(opt) == 3 else (opt[0], opt[1], "") for opt in options]
+    ticked = {value for _, value, _ in options if value in default}
+    if not interactive():
+        chosen = [value for _, value, _ in options if value in ticked]
+        answered(question, ", ".join(label for label, value, _ in options if value in ticked) or "none")
+        return chosen
+
+    cursor = 0
+    error = ""
+    lines = len(options) + 2
+
+    def draw(first=False):
+        width = _width()
+        if not first:
+            _write(_UP.format(lines))
+        hint_text = hint or "Space to tick, Enter to confirm"
+        if len(question) + len(hint_text) + 3 > width:
+            hint_text = ""
+        _write(f"{_CLEAR_LINE}{QUESTION} {Style.BRIGHT}{_truncate(question, width - 2)}{RESET} "
+               f"{DIM}{hint_text}{RESET}\n")
+        for i, (label, value, description) in enumerate(options):
+            pointer = POINTER if i == cursor else " "
+            box = f"{Fore.GREEN}◉{RESET}" if value in ticked else f"{DIM}◯{RESET}"
+            room = width - 8 - len(str(i + 1))  # "  ❯ ◉ 1 "
+            if len(label) + 2 + len(description) > room:
+                description = ""
+            label = _truncate(label, room)
+            text = f"{Fore.CYAN}{Style.BRIGHT}{label}{RESET}" if i == cursor else label
+            extra = f"  {DIM}{description}{RESET}" if description else ""
+            _write(f"{_CLEAR_LINE}  {pointer} {box} {DIM}{i + 1}{RESET} {text}{extra}\n")
+        _write(f"{_CLEAR_LINE}  {Fore.RED}{_truncate(error, width - 2)}{RESET}\n" if error else f"{_CLEAR_LINE}\n")
+
+    def collapse():
+        _write(_UP.format(lines))
+        for _ in range(lines):
+            _write(f"{_CLEAR_LINE}\n")
+        _write(_UP.format(lines))
+
+    draw(first=True)
+    try:
+        while True:
+            key = _read_key()
+            error = ""
+            if key == "up":
+                cursor = (cursor - 1) % len(options)
+            elif key == "down":
+                cursor = (cursor + 1) % len(options)
+            elif key == " " or (key.isdigit() and 1 <= int(key) <= len(options)):
+                if key != " ":
+                    cursor = int(key) - 1
+                value = options[cursor][1]
+                ticked.symmetric_difference_update({value})
+            elif key == "enter":
+                if ticked:
+                    break
+                error = "Tick at least one (Space)"
+            elif key == "escape":
+                raise Cancelled
+            else:
+                continue
+            draw()
+    except (Cancelled, KeyboardInterrupt):
+        collapse()
+        answered(question, "cancelled", mark=CROSS)
+        raise Cancelled
+    collapse()
+    answered(question, ", ".join(label for label, value, _ in options if value in ticked))
+    return [value for _, value, _ in options if value in ticked]
+
+
 def confirm(question, default=True):
     """Yes or no; Enter takes the default."""
     return select(question, [("Yes", True), ("No", False)], default=0 if default else 1,
@@ -265,6 +341,109 @@ def step(label, command, cwd=None, env=None):
     return False, output
 
 
+class Task:
+    """One line of work for tasks(): commands run one after another in cwd. A command is a list
+    (run directly) or a callable returning None on success or an error message."""
+
+    def __init__(self, label, commands, cwd=None, env=None):
+        self.label = label
+        self.commands = commands
+        self.cwd = cwd
+        self.env = env
+        self.state = "waiting"      # waiting / running / done / failed
+        self.latest = ""
+        self.lines = []
+        self.failed_command = None  # the command that failed, as text
+        self.started = None
+        self.elapsed = 0.0
+
+    def run(self):
+        self.state = "running"
+        self.started = time.monotonic()
+        for command in self.commands:
+            if callable(command):
+                # A step decided when it runs: returns None (done), an error message, or the
+                # command to run now (e.g. one naming an interpreter an earlier step created).
+                try:
+                    result = command()
+                except Exception as error:  # noqa: BLE001
+                    result = str(error)
+                if isinstance(result, str):
+                    self.lines.append(result)
+                    self.failed_command = getattr(command, "description", "")
+                    break
+                if result is None:
+                    continue
+                command = result
+            command = list(command)
+            command[0] = shutil.which(command[0]) or command[0]
+            try:
+                process = subprocess.Popen(
+                    command, cwd=self.cwd, env=self.env, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+                    stdin=subprocess.DEVNULL, text=True, encoding="utf-8", errors="replace", bufsize=1,
+                )
+            except OSError as error:
+                self.lines.append(f"couldn't run {os.path.basename(command[0])} ({error.strerror or error})")
+                self.failed_command = " ".join([os.path.basename(command[0])] + command[1:])
+                break
+            for line in process.stdout:
+                line = line.strip()
+                if line:
+                    self.lines.append(line)
+                    self.latest = line
+            if process.wait() != 0:
+                self.failed_command = " ".join([os.path.splitext(os.path.basename(command[0]))[0]] + command[1:])
+                break
+        self.elapsed = time.monotonic() - self.started
+        self.state = "failed" if self.failed_command is not None else "done"
+
+
+def tasks(items):
+    """Run Tasks side by side, one live line each (spinner, label, latest output, time). The
+    full output of a failed task is printed once everything has finished. Returns the tasks."""
+    threads = [threading.Thread(target=task.run, daemon=True) for task in items]
+    for thread in threads:
+        thread.start()
+    show = interactive()
+    frames = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"
+    label_width = max(len(task.label) for task in items)
+
+    def line(task, frame):
+        width = _width()
+        label = task.label.ljust(label_width)
+        if task.state == "done":
+            return f"{CHECK} {label} {DIM}({task.elapsed:.0f}s){RESET}"
+        if task.state == "failed":
+            return f"{CROSS} {label} {Fore.RED}failed{RESET} {DIM}({task.elapsed:.0f}s){RESET}"
+        if task.state == "waiting":
+            return f"{DIM}·{RESET} {label}"
+        elapsed = f"{int(time.monotonic() - task.started)}s"
+        room = width - label_width - len(elapsed) - 6
+        latest = _truncate(task.latest, room) if task.latest and room > 10 else ""
+        return f"{Fore.CYAN}{frame}{RESET} {label} {DIM}{elapsed}  {latest}{RESET}"
+
+    i = 0
+    if show:
+        _write("\n" * len(items))
+    while any(thread.is_alive() for thread in threads):
+        if show:
+            _write(_UP.format(len(items)))
+            for task in items:
+                _write(f"{_CLEAR_LINE}{line(task, frames[i % len(frames)])}\n")
+            i += 1
+        time.sleep(0.08)
+    if show:
+        _write(_UP.format(len(items)))
+    for task in items:
+        _write(f"{_CLEAR_LINE}{line(task, '')}\n")
+    for task in items:
+        if task.state == "failed":
+            _write(f"\n{CROSS} {Style.BRIGHT}{task.label}{RESET}: {task.failed_command or 'failed'}\n")
+            for output in task.lines[-15:]:
+                _write(f"    {DIM}{output}{RESET}\n")
+    return items
+
+
 def _truncate(value, limit):
     return value if len(value) <= limit else value[: max(limit - 1, 1)] + "…"
 

{ntc_dev_kit-1.2.1 → ntc_dev_kit-1.3.0}/ntc/wizard.py

@@ -5,7 +5,6 @@ a one-line answer, the defaults are already selected (Enter, Enter, Enter works)
 pauses for effect. The only spinner is for real work - installing dependencies - and it shows
 what that work is doing. Every answer can also be given as a flag; with --yes nothing is asked.
 """
-import json
 import os
 import shutil
 import sys
@@ -190,16 +189,9 @@ FRONTENDS = {
 
 
 def _create_frontend(plan):
-    import importlib
-    module_name, tool = FRONTENDS[plan.technology]
-    module = importlib.import_module(module_name)
-    with open(os.path.join(os.path.dirname(module.__file__), "structure.json"), encoding="utf-8") as f:
-        structure = json.load(f)
-    variables = {"project_name": plan.name}
-    if plan.technology == "flutter":
-        variables["project_camel"] = module.convert_to_camel_case(plan.name)
-    os.makedirs(plan.root, exist_ok=True)
-    module.create_from_json(plan.root, structure["{project_name}"], variables)
+    from ntc.workspace.create import render_frontend
+    tool = FRONTENDS[plan.technology][1]
+    render_frontend(plan.technology, plan.root, plan.name)
     prompts.success(f"Created {_count_files(plan.root)} files")
     if plan.install:
         command = ["npm", "install", "--no-audit", "--no-fund"] if tool == "npm" else ["flutter", "pub", "get"]
@@ -251,10 +243,18 @@ def _next_steps(plan):
 
 # ── The wizard ──────────────────────────────────────────────────────────
 
-def run(technology=None, name=None, path=None, with_auth=None, env_choice=None, install=None, assume_yes=False):
+def run(technology=None, name=None, path=None, with_auth=None, env_choice=None, install=None, assume_yes=False,
+        apps=None, git=None):
     """Ask what isn't given, show the plan, create the project. Returns the project folder, or
-    None if cancelled. Esc or Ctrl+C at any question cancels without writing anything."""
+    None if cancelled. Esc or Ctrl+C at any question cancels without writing anything.
+
+    Picking several apps (or passing apps=[roles]) makes a workspace instead: the apps side by
+    side in one folder, wired to each other, with an ntc.toml for `ntc start`."""
+    from ntc.workspace import config as workspace_config
     print(f"\n{Style.BRIGHT}ntc{RESET} {DIM}— new project{RESET}\n")
+    inside = workspace_config.find_root()
+    if inside and not apps and technology is None:
+        prompts.info(f"You're in the {os.path.basename(inside)} workspace - `ntc add` adds an app to it.")
     plan = Plan()
     try:
         if name is None:
@@ -267,10 +267,20 @@ def run(technology=None, name=None, path=None, with_auth=None, env_choice=None,
             prompts.answered("Project name", name)
         plan.name = name
 
-        if technology is None:
-            technology = prompts.select("What are you building?", TECHNOLOGIES)
+        if technology is None and not apps:
+            options = [(label, role, workspace_config.KINDS[kind]["label"])
+                       for role, label, kind in workspace_config.ROLES]
+            apps = prompts.multiselect("What are you building?", options,
+                                       hint="Space to tick (several = a workspace), Enter to confirm")
+            if len(apps) == 1:
+                technology = workspace_config.ROLE_KINDS[apps[0]]
+                apps = None
+        elif apps:
+            prompts.answered("What are you building?", ", ".join(apps))
         else:
             prompts.answered("What are you building?", LABELS.get(technology, technology))
+        if apps:
+            raise _Workspace  # a workspace asks its own questions from here
         plan.technology = technology
 
         _ask_location(plan, path, assume_yes)
@@ -294,6 +304,10 @@ def run(technology=None, name=None, path=None, with_auth=None, env_choice=None,
     except prompts.Cancelled:
         print(f"\n{DIM}Cancelled - nothing was written.{RESET}")
         return None
+    except _Workspace:
+        from ntc.workspace.create import run_init
+        return run_init(plan.name, apps, path=path, with_auth=with_auth, env_choice=env_choice,
+                        install=install, git=git, assume_yes=assume_yes)
 
     print()
     started = time.monotonic()
@@ -312,6 +326,10 @@ def run(technology=None, name=None, path=None, with_auth=None, env_choice=None,
     return plan.root
 
 
+class _Workspace(Exception):
+    """Several apps were picked: the workspace flow takes over."""
+
+
 def _is_valid_location_name(plan):
     """A project created in an existing folder takes that folder's name; make sure it's usable."""
     if plan.technology == "django" and not is_valid_project_name(plan.name):

ntc_dev_kit-1.3.0/ntc/workspace/__init__.py

@@ -0,0 +1,2 @@
+"""Workspaces: several apps (backend, website, dashboards, mobile) in one folder, described by
+ntc.toml at its root, created by `ntc init` and run with `ntc start`."""