bazis-cli 2.5.0__tar.gz → 2.6.1__tar.gz

{bazis_cli-2.5.0 → bazis_cli-2.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bazis-cli
-Version: 2.5.0
+Version: 2.6.1
 Summary: The bazis command: creates, extends and audits Bazis products, backend and frontend, with Claude (Claude Agent SDK).
 Author-email: Ilya Kharyn <ilya.tt07@gmail.com>
 Maintainer-email: Ilya Kharyn <ilya.tt07@gmail.com>
@@ -19,7 +19,7 @@ Classifier: Framework :: FastAPI
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 Requires-Dist: bazis>=2.16.0
-Requires-Dist: bazis-mcp>=2.5.0
+Requires-Dist: bazis-mcp>=2.6.0
 Requires-Dist: claude-agent-sdk>=0.2.163
 Provides-Extra: test
 Requires-Dist: pytest>=8; extra == "test"
@@ -82,8 +82,9 @@ bazis change          # the changes typed one after another; an empty line ends
   [bazis-front](https://github.com/ecofuture-tech/bazis-front): the specs of the product
   (`spec/`: roles, entities, workflows, access, scenarios, screens, design), the backend
   that satisfies them, the contract exported from it (`contract/`), a React + TypeScript
-  frontend (`frontend/`) with the screens composed from the components of bazis-front,
-  and the end-to-end tests of the scenarios run against the backend. It needs Node.js
+  frontend (`frontend/`) with the screens generated from their specs (`bazis_front
+  screens`), the end-to-end tests of the scenarios run against the backend and the
+  screenshots of the screens looked at by the agent. It needs Node.js
   22.12 or newer with npm, and PostgreSQL for the contract and the end-to-end tests;
   `--no-frontend` builds only the backend.
 - The product is in the language of its description and in English, the language of the

{bazis_cli-2.5.0 → bazis_cli-2.6.1}/README.md

@@ -54,8 +54,9 @@ bazis change          # the changes typed one after another; an empty line ends
   [bazis-front](https://github.com/ecofuture-tech/bazis-front): the specs of the product
   (`spec/`: roles, entities, workflows, access, scenarios, screens, design), the backend
   that satisfies them, the contract exported from it (`contract/`), a React + TypeScript
-  frontend (`frontend/`) with the screens composed from the components of bazis-front,
-  and the end-to-end tests of the scenarios run against the backend. It needs Node.js
+  frontend (`frontend/`) with the screens generated from their specs (`bazis_front
+  screens`), the end-to-end tests of the scenarios run against the backend and the
+  screenshots of the screens looked at by the agent. It needs Node.js
   22.12 or newer with npm, and PostgreSQL for the contract and the end-to-end tests;
   `--no-frontend` builds only the backend.
 - The product is in the language of its description and in English, the language of the

{bazis_cli-2.5.0 → bazis_cli-2.6.1}/bazis/contrib/cli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.5.0'
-__version_tuple__ = version_tuple = (2, 5, 0)
+__version__ = version = '2.6.1'
+__version_tuple__ = version_tuple = (2, 6, 1)
 
-__commit_id__ = commit_id = 'g7cba9682b'
+__commit_id__ = commit_id = 'g27dcdfabb'

{bazis_cli-2.5.0 → bazis_cli-2.6.1}/bazis_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bazis-cli
-Version: 2.5.0
+Version: 2.6.1
 Summary: The bazis command: creates, extends and audits Bazis products, backend and frontend, with Claude (Claude Agent SDK).
 Author-email: Ilya Kharyn <ilya.tt07@gmail.com>
 Maintainer-email: Ilya Kharyn <ilya.tt07@gmail.com>
@@ -19,7 +19,7 @@ Classifier: Framework :: FastAPI
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 Requires-Dist: bazis>=2.16.0
-Requires-Dist: bazis-mcp>=2.5.0
+Requires-Dist: bazis-mcp>=2.6.0
 Requires-Dist: claude-agent-sdk>=0.2.163
 Provides-Extra: test
 Requires-Dist: pytest>=8; extra == "test"
@@ -82,8 +82,9 @@ bazis change          # the changes typed one after another; an empty line ends
   [bazis-front](https://github.com/ecofuture-tech/bazis-front): the specs of the product
   (`spec/`: roles, entities, workflows, access, scenarios, screens, design), the backend
   that satisfies them, the contract exported from it (`contract/`), a React + TypeScript
-  frontend (`frontend/`) with the screens composed from the components of bazis-front,
-  and the end-to-end tests of the scenarios run against the backend. It needs Node.js
+  frontend (`frontend/`) with the screens generated from their specs (`bazis_front
+  screens`), the end-to-end tests of the scenarios run against the backend and the
+  screenshots of the screens looked at by the agent. It needs Node.js
   22.12 or newer with npm, and PostgreSQL for the contract and the end-to-end tests;
   `--no-frontend` builds only the backend.
 - The product is in the language of its description and in English, the language of the

{bazis_cli-2.5.0 → bazis_cli-2.6.1}/bazis_cli.egg-info/SOURCES.txt

@@ -24,6 +24,8 @@ bazis_cli.egg-info/top_level.txt
 docs/releases/2.4.0.md
 docs/releases/2.4.1.md
 docs/releases/2.5.0.md
+docs/releases/2.6.0.md
+docs/releases/2.6.1.md
 evals/__init__.py
 evals/grade.py
 evals/run.py

{bazis_cli-2.5.0 → bazis_cli-2.6.1}/bazis_cli.egg-info/requires.txt

@@ -1,5 +1,5 @@
 bazis>=2.16.0
-bazis-mcp>=2.5.0
+bazis-mcp>=2.6.0
 claude-agent-sdk>=0.2.163
 
 [dev]

{bazis_cli-2.5.0 → bazis_cli-2.6.1}/bazis_cli.egg-info/scm_file_list.json

@@ -16,6 +16,8 @@
     "docs/releases/2.4.0.md",
     "docs/releases/2.4.1.md",
     "docs/releases/2.5.0.md",
+    "docs/releases/2.6.0.md",
+    "docs/releases/2.6.1.md",
     "evals/__init__.py",
     "evals/grade.py",
     "evals/run.py",

bazis_cli-2.6.1/bazis_cli.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "2.6.1",
+  "distance": 0,
+  "node": "g27dcdfabbf66447ef51bf37bdeb01b5ad7ce85f9",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-10-18"
+}

bazis_cli-2.6.1/docs/releases/2.6.0.md

@@ -0,0 +1,15 @@
+# bazis-cli 2.6.0
+
+## Changes
+
+- bazis-cli requires bazis-mcp 2.6.0 (`bazis-mcp>=2.6.0`): the tasks and the rules of
+  bazis-front 0.3.0. A new product requires bazis-front 0.3.0; its screens are generated
+  from their specs (`bazis_front screens`), with an extension (`extend`) or a custom screen
+  (`custom`) only for what a spec cannot say, and its screenshots (`bazis_front shots`)
+  are taken and looked at, at most three rounds. A change of a product generates its
+  screens again and ends with the whole round of the final checks.
+- The evals grade the screens of a product: `bazis_front screens --check` and `bazis_front
+  shots --check` (a comparison with the specs, the screenshots not taken by the grader)
+  with `design` and `e2e`, and no TSX of the product in `frontend/src/` but the code of its
+  custom and extended screens (the copies, the generated screens and the template are not
+  its own); the detail counts the lines of TSX written by hand.

bazis_cli-2.6.1/docs/releases/2.6.1.md

@@ -0,0 +1,9 @@
+# bazis-cli 2.6.1
+
+## Changes
+
+- The evals grader keeps the settings of the machine (the database and GDAL) and creates
+  the database on the server of the project.
+- The check that the migrations apply does not pass silently: when the database server is
+  unknown or createdb is missing, the check fails.
+- The test of the requirements to the latest releases of bazis and bazis-mcp is restored.

{bazis_cli-2.5.0 → bazis_cli-2.6.1}/evals/grade.py

@@ -18,14 +18,16 @@ Python of the project (`.venv`) against PostgreSQL and Redis of `.env`. It does
 on the names the agent chose: it checks that the project loads and passes its checks, has
 the expected Bazis packages, complete migrations that apply, models and routes of its own,
 and tests that pass. A product with a frontend (`frontend = true`) also needs specs valid
-against a fresh contract, generated files that are not stale, a frontend that builds and
-passes its lint and component tests, and end-to-end tests of its scenarios that pass
+against a fresh contract, generated files that are not stale, screens generated from their
+specs (no TSX of its own but that of its custom and extended screens), a frontend that
+builds and passes its lint and component tests, and end-to-end tests of its scenarios that pass
 against the backend with the test data of `manage.py e2e_data` (Node.js is needed). A task
 with a `language` needs the product in that language and in English, with its catalog.
 The grader runs on POSIX only (macOS, Linux): it stops the servers and the commands it
 starts by their process group.
 """
 
+import json
 import os
 import re
 import secrets
@@ -49,6 +51,32 @@ BAZIS_CHECK_PREFIXES = (
     'async_request.', 'bg.', 'front.',
 )
 TIMEOUT = 900
+#: the settings of the machine that the agent was given and the project must keep when it is
+#: graded: the PostgreSQL and Redis servers and the GDAL and GEOS libraries. The other `BS_*`
+#: variables are those of the project (its `.env`), the name of the database is the grader's
+MACHINE_SETTINGS = (
+    'BS_DATABASES__DEFAULT__HOST', 'BS_DATABASES__DEFAULT__PORT', 'BS_DATABASES__DEFAULT__USER',
+    'BS_DATABASES__DEFAULT__PASSWORD', 'BS_CACHES__DEFAULT__LOCATION',
+    'BS_GDAL_LIBRARY_PATH', 'BS_GEOS_LIBRARY_PATH',
+)
+#: run by `manage.py shell` of the project: prints the server of its database as JSON
+DATABASE_SERVER = """\
+import json
+from django.conf import settings
+db = settings.DATABASES['default']
+print(json.dumps({key: db.get(key.upper()) or None for key in ('host', 'port', 'user', 'password')}))
+"""
+#: the TSX of `frontend/src/` that a product does not write: the generated screens and the
+#: template (its entry, its app and its login), besides the assets that bazis-front copied
+#: (the files of `assets` in its lock, among them the shadcn components of `components/ui/`)
+NOT_WRITTEN = ('bazis/', 'screens/generated/', 'main.tsx', 'app/', 'screens/login/')
+#: prints `custom` and `extend` of the specs of the screens by their ids, as JSON (run with the
+#: Python of the project, which has PyYAML with bazis-front)
+SCREEN_SPECS = """\
+import json, pathlib, yaml
+specs = [yaml.safe_load(path.read_text(encoding='utf-8')) for path in pathlib.Path('spec/screens').glob('*.yaml')]
+print(json.dumps({it['id']: {key: it[key] for key in ('custom', 'extend') if key in it} for it in specs}))
+"""
 
 
 @dataclass
@@ -119,13 +147,27 @@ def local_apps(project: Path) -> set[str]:
 
 def project_env(database: str) -> dict:
     """
-    The environment of the project: its own .env and project.env, a database of its own.
+    The environment of the project: its own .env and project.env and the settings of the
+    machine (`MACHINE_SETTINGS`), a database of its own.
     """
-    env = {k: v for k, v in os.environ.items() if not k.startswith(('BS_', 'DJANGO_'))}
+    env = {
+        k: v for k, v in os.environ.items()
+        if k in MACHINE_SETTINGS or not k.startswith(('BS_', 'DJANGO_'))
+    }
     env['BS_DATABASES__DEFAULT__NAME'] = database
     return env
 
 
+def postgres_command(program: str, server: dict, *args: str) -> list[str]:
+    """
+    A PostgreSQL client command (`createdb`, `dropdb`) for the server of the project.
+    """
+    command = [program, '-h', server['host'] or 'localhost', '-U', server['user'] or 'postgres']
+    if server['port']:
+        command += ['-p', str(server['port'])]
+    return [*command, *args]
+
+
 def package_warnings(messages: list[dict]) -> list[str]:
     """
     The ids of the warnings of the Bazis packages among the messages of `bazis_doctor`; the
@@ -183,26 +225,7 @@ def grade(project: Path, task: dict) -> list[Check]:
 
     if task.get('frontend'):
         checks += frontend_checks(project, env, task.get('min_scenarios', 1))
-    if shutil.which('createdb'):
-        created = subprocess.run(
-            ['createdb', '-h', 'localhost', '-U', 'postgres', database],
-            env={**env, 'PGPASSWORD': 'postgres'}, capture_output=True, text=True,
-        )
-        try:
-            migrate = run(project, ['manage.py', 'migrate', '--noinput'], env)
-            migrated = created.returncode == 0 and migrate.returncode == 0
-            checks.append(Check(
-                'migrations apply', migrated, created.stderr.strip() or tail(migrate, 6),
-            ))
-            if task.get('frontend'):
-                checks += frontend_database_checks(project, env, migrated)
-        finally:
-            subprocess.run(
-                ['dropdb', '-h', 'localhost', '-U', 'postgres', '--if-exists', '--force', database],
-                env={**env, 'PGPASSWORD': 'postgres'}, capture_output=True,
-            )
-    elif task.get('frontend'):
-        checks += frontend_database_checks(project, env, False, 'no PostgreSQL (createdb)')
+    checks += database_checks(project, env, database, bool(task.get('frontend')))
 
     collected = run(project, ['-m', 'pytest', '--collect-only', '-q', '-p', 'no:cacheprovider'], env)
     count = re.search(r'(\d+) tests? collected', collected.stdout)
@@ -216,6 +239,44 @@ def grade(project: Path, task: dict) -> list[Check]:
     return checks
 
 
+def database_checks(project: Path, env: dict, database: str, frontend: bool) -> list[Check]:
+    """
+    The checks that need the database of the grading: the migrations apply to a database
+    created on the server of the project (dropped afterwards), then the checks of the
+    frontend on it. Without `createdb` or the server of the project they fail with the
+    reason instead of dropping out of the result.
+    """
+    server = None
+    if shutil.which('createdb'):
+        probe = run(project, ['manage.py', 'shell', '-c', DATABASE_SERVER], env)
+        server = mcp_project.parse_json(probe.stdout)
+        reason = 'server of the database: ' + (tail(probe, 6) or 'no output')
+    else:
+        reason = 'no PostgreSQL (createdb)'
+    if not server:
+        checks = [Check('migrations apply', False, reason)]
+        if frontend:
+            checks += frontend_database_checks(project, env, False, reason)
+        return checks
+    client_env = {**env, 'PGPASSWORD': server['password'] or ''}
+    created = subprocess.run(
+        postgres_command('createdb', server, database),
+        env=client_env, capture_output=True, text=True,
+    )
+    try:
+        migrate = run(project, ['manage.py', 'migrate', '--noinput'], env)
+        migrated = created.returncode == 0 and migrate.returncode == 0
+        checks = [Check('migrations apply', migrated, created.stderr.strip() or tail(migrate, 6))]
+        if frontend:
+            checks += frontend_database_checks(project, env, migrated)
+        return checks
+    finally:
+        subprocess.run(
+            postgres_command('dropdb', server, '--if-exists', '--force', database),
+            env=client_env, capture_output=True,
+        )
+
+
 def language_check(project: Path, info: dict, language: str, env: dict) -> Check:
     """
     The product is in the language of its description and in English (`LANGUAGES`), the
@@ -278,12 +339,14 @@ def frontend_checks(project: Path, env: dict, min_scenarios: int) -> list[Check]
     stale = [
         done for done in (
             run(project, ['manage.py', 'bazis_front', command, '--check'], env)
-            for command in ('design', 'e2e')
+            for command in ('design', 'screens', 'e2e', 'shots')
         ) if done.returncode
     ]
     checks.append(Check(
-        'theme and end-to-end tests generated', not stale, '\n'.join(tail(d, 4) for d in stale),
+        'theme, screens, end-to-end tests and screenshots generated', not stale,
+        '\n'.join(tail(d, 4) for d in stale),
     ))
+    checks.append(written_screens(project, env))
 
     build = npm(frontend, ['run', 'build'], env)
     checks.append(Check('frontend builds', build.returncode == 0, tail(build, 8)))
@@ -298,6 +361,44 @@ def frontend_checks(project: Path, env: dict, min_scenarios: int) -> list[Check]
     return checks
 
 
+def written_screens(project: Path, env: dict) -> Check:
+    """
+    The screens are generated from their specs: the TSX that the product writes in
+    `frontend/src/` (not NOT_WRITTEN) is only the code of a custom screen (`custom`: its
+    directory `screens/<id>/`, or the module it names) or of an extended one (`extend`: its
+    directory). The detail counts the lines of that TSX, a measure of the hand-written code.
+    """
+    title = 'no TSX of its own but that of the custom and extended screens'
+    specs = run(project, ['-c', SCREEN_SPECS], env)
+    screens = mcp_project.parse_json(specs.stdout)
+    if screens is None:
+        return Check(title, False, 'the specs of the screens: ' + tail(specs, 4))
+    allowed = []
+    for id_, spec in screens.items():
+        custom = spec.get('custom')
+        if custom is True or spec.get('extend'):
+            allowed.append(f'screens/{id_}/')
+        elif custom:
+            module = custom['module'].removeprefix('@/')
+            allowed += [f'{module}.tsx', f'{module}/']
+    source = project / 'frontend' / 'src'
+    lock = json.loads((project / 'frontend' / 'bazis-front.lock.json').read_text(encoding='utf-8'))
+    copied = {
+        file.removeprefix('src/') for asset in lock['assets'].values() for file in asset.get('files', ())
+    }
+    written = {
+        name: path for path in sorted(source.rglob('*.tsx'))
+        if not (name := path.relative_to(source).as_posix()).startswith(NOT_WRITTEN)
+        and name not in copied
+    }
+    lines = sum(len(path.read_text(encoding='utf-8').splitlines()) for path in written.values())
+    other = [name for name in written if not name.startswith(tuple(allowed))]
+    detail = f'lines of TSX written by hand: {lines}'
+    if other:
+        detail += '; not of a custom or extended screen: ' + ', '.join(other)
+    return Check(title, not other, detail)
+
+
 def project_package(project: Path) -> str:
     """
     The project package, from DJANGO_SETTINGS_MODULE of manage.py.

{bazis_cli-2.5.0 → bazis_cli-2.6.1}/pyproject.toml

@@ -37,7 +37,7 @@ dependencies = [
     # the settings of a project without .venv (--no-venv), the languages of Django and the
     # modules a project package must not hide are those of the Python of the CLI
     "bazis>=2.16.0",
-    "bazis-mcp>=2.5.0",
+    "bazis-mcp>=2.6.0",
     "claude-agent-sdk>=0.2.163",
 ]
 

{bazis_cli-2.5.0 → bazis_cli-2.6.1}/tests/test_cli.py

@@ -15,6 +15,8 @@
 import io
 import json
 import sys
+import tomllib
+from importlib import metadata
 from pathlib import Path
 from types import SimpleNamespace
 
@@ -337,8 +339,11 @@ def test_add_to_a_product_with_a_frontend(tmp_path, fake_agent, capsys):
     assert 'package_guide("bazis-statusy")' in backend
     # a project made before the ports gets them
     assert prompts.ports_text(scaffold.project_ports(tmp_path)) in frontend
-    order = ['spec/', 'bazis_front contract', 'front_check', 'front_catalog', 'bazis_front add',
-             'bazis_front e2e', 'e2e_data', 'the final checks of the rules']
+    # the screens generated again, then the whole round of the final checks (bazis-mcp 2.6)
+    frontend = ' '.join(frontend.split())
+    order = ['spec/', 'bazis_front contract', 'front_check', 'bazis_front screens',
+             'bazis_front e2e', 'e2e_data', 'the whole round of the final checks of the rules',
+             'npm run build', 'bazis_front screens --check']
     positions = [frontend.index(text) for text in order]
     assert positions == sorted(positions)
     assert FRONTEND_RULES in options.system_prompt['append']
@@ -359,7 +364,7 @@ def test_add_the_frontend(tmp_path, fake_agent):
     assert '"Building the frontend of a product"' in prompt
     assert 'the final checks of the rules' in prompt
     assert 'the specs describe the backend and what the project needs it for' in prompt
-    assert 'requirement `bazis-front>=0.1.0`' in prompt
+    assert f'requirement `{scaffold.FRONTEND_REQUIREMENT}`' in prompt
     assert FRONTEND_RULES in options.system_prompt['append']
 
 
@@ -372,7 +377,7 @@ def test_add_the_frontend_from_a_build(tmp_path, fake_agent, monkeypatch):
 
     prompt, _ = fake_agent[0]
     assert 'requirement `/wheels/bazis_front-0.1.0.whl`' in prompt
-    assert 'bazis-front>=0.1.0' not in prompt
+    assert scaffold.FRONTEND_REQUIREMENT not in prompt
 
 
 def test_add_without_node(tmp_path, fake_agent, monkeypatch, capsys):
@@ -505,7 +510,11 @@ def test_change(tmp_path, fake_agent, sessions, capsys):
     assert main.main(['change', 'Add the authors', *project, '--budget', '2']) == 0
     prompt, options = fake_agent[-1]
     assert options.resume == 's' and options.max_budget_usd == 2
-    assert prompt == 'Add the authors\n\nAfter the change, run the final checks of the rules once.\n'
+    # the request, the final checks once, and the headings of the summary (bazis-mcp 2.6)
+    assert prompt == (
+        'Add the authors\n\nAfter the change, run the final checks of the rules once.\n\n'
+        f'{prompts.SUMMARY}\n'
+    )
 
     assert main.main(['change', 'Add the authors', *project, '--new-session']) == 0
     assert fake_agent[-1][1].resume is None
@@ -608,3 +617,23 @@ def test_change_without_a_terminal(tmp_path, fake_agent, monkeypatch, capsys):
     assert 'bazis change "..."' in capsys.readouterr().err
     assert fake_agent == []
 
+
+def test_requirements_are_the_latest_releases():
+    """
+    The CLI requires at least the releases that bazis-mcp describes: its catalog of the
+    released packages gives bazis, and the installed bazis-mcp is the release of that catalog.
+    """
+    from bazis.contrib.mcp import catalog
+
+    def version(text):
+        return tuple(int(part) for part in text.split('.')[:3])
+
+    installed = metadata.version('bazis-mcp')
+    if 'dev' in installed:
+        pytest.skip(f'bazis-mcp {installed} is not a release')
+    pyproject = tomllib.loads((Path(__file__).parent.parent / 'pyproject.toml').read_text())
+    released = {**{name: entry['version'] for name, entry in catalog.catalog().items()}, 'bazis-mcp': installed}
+    pins = dict(it.split('>=') for it in pyproject['project']['dependencies'] if it.startswith('bazis'))
+    assert pins.keys() == {'bazis', 'bazis-mcp'}
+    for name, minimum in pins.items():
+        assert version(minimum) >= version(released[name]), f'{name}>={minimum}, released {released[name]}'

{bazis_cli-2.5.0 → bazis_cli-2.6.1}/tests/test_evals.py

@@ -12,10 +12,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import contextlib
+import io
 import json
 import os
 import subprocess
+import sys
 import time
+import types
+
+import pytest
 
 from bazis.contrib.mcp import catalog, scaffold
 
@@ -96,11 +102,45 @@ def test_local_apps(tmp_path):
 def test_project_env_isolates_the_database(monkeypatch):
     monkeypatch.setenv('BS_DEBUG', 'false')
     monkeypatch.setenv('DJANGO_SETTINGS_MODULE', 'other.settings')
+    monkeypatch.setenv('BS_DATABASES__DEFAULT__NAME', 'other')
     env = grade.project_env('eval_x')
     assert env['BS_DATABASES__DEFAULT__NAME'] == 'eval_x'
     assert 'BS_DEBUG' not in env and 'DJANGO_SETTINGS_MODULE' not in env
 
 
+def test_project_env_keeps_the_settings_of_the_machine(monkeypatch):
+    machine = {
+        'BS_DATABASES__DEFAULT__PORT': '55910', 'BS_GDAL_LIBRARY_PATH': '/opt/lib/libgdal.dylib',
+        'BS_GEOS_LIBRARY_PATH': '/opt/lib/libgeos_c.dylib', 'PGHOST': 'db', 'DYLD_LIBRARY_PATH': '/opt/lib',
+    }
+    for key, value in machine.items():
+        monkeypatch.setenv(key, value)
+    assert machine.items() <= grade.project_env('eval_x').items()
+
+
+def test_database_server_of_the_project(monkeypatch):
+    settings = types.SimpleNamespace(DATABASES={'default': {
+        'HOST': 'db', 'PORT': '55910', 'USER': 'owner', 'PASSWORD': 'secret', 'NAME': 'x',
+    }})
+    monkeypatch.setitem(sys.modules, 'django', types.ModuleType('django'))
+    monkeypatch.setitem(sys.modules, 'django.conf', types.SimpleNamespace(settings=settings))
+    output = io.StringIO()
+    with contextlib.redirect_stdout(output):
+        exec(grade.DATABASE_SERVER, {})
+    server = json.loads(output.getvalue())
+    assert server == {'host': 'db', 'port': '55910', 'user': 'owner', 'password': 'secret'}
+    assert grade.postgres_command('createdb', server, 'eval_x') == [
+        'createdb', '-h', 'db', '-U', 'owner', '-p', '55910', 'eval_x',
+    ]
+
+
+def test_postgres_command_defaults():
+    server = {'host': None, 'port': None, 'user': None, 'password': None}
+    assert grade.postgres_command('dropdb', server, '--force', 'x') == [
+        'dropdb', '-h', 'localhost', '-U', 'postgres', '--force', 'x',
+    ]
+
+
 def test_summary(tmp_path):
     checks = [grade.Check('project loads', True), grade.Check('tests pass', False, 'boom\n1 failed')]
     result = {'task': 'tracker', 'seconds': 120, 'cost_usd': 1.5, 'turns': 30,
@@ -111,8 +151,6 @@ def test_summary(tmp_path):
 
 
 def test_running_needs_a_budget():
-    import pytest
-
     with pytest.raises(SystemExit, match='budget'):
         run.main_cli(['--task', 'tracker'])
 
@@ -125,7 +163,7 @@ def product(tmp_path, scenarios: int):
     scaffold.write_files(tmp_path, 'desk', frontend=True)
     generated = tmp_path / 'frontend' / 'e2e' / 'generated'
     generated.mkdir(parents=True)
-    (tmp_path / 'frontend' / 'bazis-front.lock.json').write_text('{}')
+    (tmp_path / 'frontend' / 'bazis-front.lock.json').write_text('{"assets": {}}')
     for index in range(scenarios):
         (generated / f'scenario-{index}.spec.ts').write_text('')
     (generated / 'product.ts').write_text('')
@@ -139,6 +177,8 @@ def test_frontend_checks(tmp_path, monkeypatch):
 
     def fake_run(project, args, env):
         commands.append(args)
+        if args[0] == '-c':
+            return done(0, '{}')
         if args[2] == 'check':
             return done(1, json.dumps({'contract': True, 'errors': 1, 'warnings': 1, 'issues': issues}))
         return done(1 if args[2] == 'e2e' else 0)
@@ -153,10 +193,82 @@ def test_frontend_checks(tmp_path, monkeypatch):
     assert checks['specs valid against the contract'].detail == 'P019 spec/product.yaml#/roles/0'
     assert not checks['at least 3 scenarios'].passed
     assert checks['at least 3 scenarios'].detail == 'scenario-0.spec, scenario-1.spec'
-    assert not checks['theme and end-to-end tests generated'].passed
+    assert not checks['theme, screens, end-to-end tests and screenshots generated'].passed
+    assert checks['no TSX of its own but that of the custom and extended screens'].passed
     assert checks['frontend builds'].passed
     assert not checks['frontend lint and component tests pass'].passed
-    assert ['manage.py', 'bazis_front', 'design', '--check'] in commands
+    for command in ('design', 'screens', 'e2e', 'shots'):
+        assert ['manage.py', 'bazis_front', command, '--check'] in commands
+
+
+def test_written_screens(tmp_path, monkeypatch):
+    """
+    The TSX that a product writes is only that of its custom and extended screens: not of a
+    screen generated from its spec, nor elsewhere in `src/`; the copies, the generated
+    screens and the template are not its own. The lines written are counted.
+    """
+    screens = {
+        'loan-list': {'custom': True},
+        'book-card': {'extend': True},
+        'reader-list': {'custom': {'module': '@/screens/readers', 'export': 'ReaderListScreen'}},
+        'book-list': {},
+    }
+    monkeypatch.setattr(grade, 'run', lambda project, args, env: done(0, json.dumps(screens)))
+    source = tmp_path / 'frontend' / 'src'
+    files = {
+        # the custom and extended screens, their own files too
+        'screens/loan-list/index.tsx': 3, 'screens/loan-list/parts.tsx': 2,
+        'screens/book-card/extend.tsx': 4, 'screens/readers.tsx': 1,
+        # not the product's
+        'screens/generated/book-list.tsx': 50, 'bazis/ui/list/index.tsx': 50,
+        'app/router.tsx': 50, 'main.tsx': 50, 'screens/login/index.tsx': 50,
+        'screens/book-list/index.tsx': 5, 'components/badge.tsx': 6,
+        'screens/loan-list-extra/index.tsx': 7, 'i18n/en.ts': 50,
+        # the screen of a custom module elsewhere has no directory of its own
+        'screens/reader-list/index.tsx': 8,
+    }
+    for name, lines in files.items():
+        (source / name).parent.mkdir(parents=True, exist_ok=True)
+        (source / name).write_text('x\n' * lines)
+    # the shadcn components that bazis-front copied are in its lock: not the product's
+    (source / 'components' / 'ui').mkdir(parents=True)
+    (source / 'components' / 'ui' / 'button.tsx').write_text('x\n' * 100)
+    (source.parent / 'bazis-front.lock.json').write_text(json.dumps({
+        # an entry of an old dev-lock has no `files`
+        'assets': {'button': {'files': {'src/components/ui/button.tsx': 'sha256:0'}}, 'old': {}},
+    }))
+
+    check = grade.written_screens(tmp_path, {})
+
+    assert not check.passed and check.name.startswith('no TSX of its own')
+    assert check.detail == (
+        'lines of TSX written by hand: 36; not of a custom or extended screen: '
+        'components/badge.tsx, screens/book-list/index.tsx, screens/loan-list-extra/index.tsx, '
+        'screens/reader-list/index.tsx'
+    )
+
+    for name in ('screens/book-list/index.tsx', 'components/badge.tsx', 'screens/loan-list-extra/index.tsx',
+                 'screens/reader-list/index.tsx'):
+        (source / name).unlink()
+    check = grade.written_screens(tmp_path, {})
+    assert check.passed and check.detail == 'lines of TSX written by hand: 10'
+
+
+def test_written_screens_reads_the_specs(tmp_path):
+    """
+    The specs of the screens are read with the Python of the project (PyYAML of bazis-front).
+    """
+    pytest.importorskip('yaml')
+    (tmp_path / 'spec' / 'screens').mkdir(parents=True)
+    (tmp_path / 'spec' / 'screens' / 'loan-list.yaml').write_text('id: loan-list\ncustom: true\n')
+    (tmp_path / 'spec' / 'screens' / 'book-list.yaml').write_text('id: book-list\nprimitive: list\n')
+    (tmp_path / 'frontend' / 'src' / 'screens' / 'loan-list').mkdir(parents=True)
+    (tmp_path / 'frontend' / 'src' / 'screens' / 'loan-list' / 'index.tsx').write_text('x\n')
+    (tmp_path / 'frontend' / 'bazis-front.lock.json').write_text('{"assets": {}}')
+
+    check = grade.written_screens(tmp_path, {**os.environ})
+
+    assert check.passed and check.detail == 'lines of TSX written by hand: 1'
 
 
 def test_frontend_checks_without_a_frontend(tmp_path):
@@ -173,6 +285,50 @@ def test_frontend_database_checks_without_a_database(tmp_path):
     ]
 
 
+def probe_stub(monkeypatch, output: str, returncode: int = 0):
+    monkeypatch.setattr(grade.shutil, 'which', lambda name: '/usr/bin/createdb')
+    monkeypatch.setattr(grade, 'run', lambda project, args, env: done(returncode, output))
+
+
+@pytest.mark.parametrize('frontend', [False, True])
+@pytest.mark.parametrize('output', ['Traceback: no module', 'not json'])
+def test_database_checks_fail_when_the_server_is_unknown(tmp_path, monkeypatch, frontend, output):
+    probe_stub(monkeypatch, output, 1)
+    project = product(tmp_path, 1)
+    checks = grade.database_checks(project, {}, 'eval_x', frontend)
+    reason = 'server of the database: ' + output
+    expected = [('migrations apply', False, reason)]
+    if frontend:
+        expected += [('contract fresh', False, reason), ('end-to-end tests pass', False, reason)]
+    assert [(c.name, c.passed, c.detail) for c in checks] == expected
+
+
+@pytest.mark.parametrize('frontend', [False, True])
+def test_database_checks_without_createdb(tmp_path, monkeypatch, frontend):
+    monkeypatch.setattr(grade.shutil, 'which', lambda name: None)
+    monkeypatch.setattr(grade, 'run', lambda *a: pytest.fail('the server must not be probed'))
+    checks = grade.database_checks(product(tmp_path, 1), {}, 'eval_x', frontend)
+    assert [(c.name, c.passed, c.detail) for c in checks][0] == (
+        'migrations apply', False, 'no PostgreSQL (createdb)',
+    )
+    assert len(checks) == (3 if frontend else 1)
+
+
+def test_database_checks_create_migrate_and_drop(tmp_path, monkeypatch):
+    server = {'host': 'db', 'port': None, 'user': 'owner', 'password': 'secret'}
+    probe_stub(monkeypatch, json.dumps(server))
+    commands = []
+
+    def fake_subprocess(command, **kwargs):
+        commands.append(command[0])
+        return subprocess.CompletedProcess(command, 0, '', '')
+
+    monkeypatch.setattr(grade.subprocess, 'run', fake_subprocess)
+    checks = grade.database_checks(tmp_path, {}, 'eval_x', False)
+    assert [(c.name, c.passed) for c in checks] == [('migrations apply', True)]
+    assert commands == ['createdb', 'dropdb']
+
+
 def test_end_to_end_needs_the_test_data(tmp_path, monkeypatch):
     monkeypatch.setattr(grade, 'run', lambda project, args, env: done(1, 'Unknown command: e2e_data'))
     check = grade.end_to_end(product(tmp_path, 1), {})

bazis_cli-2.5.0/bazis_cli.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "2.5.0",
-  "distance": 0,
-  "node": "g7cba9682b5505940f5ee643f9a2af645105afad7",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-10-16"
-}