bazis-cli 2.4.1__tar.gz → 2.6.0__tar.gz

{bazis_cli-2.4.1 → bazis_cli-2.6.0}/.github/workflows/tests.yml

@@ -20,7 +20,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - uses: astral-sh/setup-uv@v6
-      - run: uvx ruff check bazis tests
+      - run: uvx ruff check bazis tests evals
 
   tests:
     name: tests (python ${{ matrix.python }}, ${{ matrix.resolution }})
@@ -36,18 +36,10 @@ jobs:
           - python: '3.12'
             resolution: lowest-direct
 
-    # the tests build a project and check it without PostgreSQL or Redis: no services
+    # the tests write a project without PostgreSQL, Redis or GDAL: no services
     steps:
       - uses: actions/checkout@v4
 
-      - name: Install GDAL (required by the PostGIS database backend)
-        # a stalled Ubuntu mirror must fail the step quickly instead of hanging the job
-        timeout-minutes: 10
-        run: |
-          APT="sudo apt-get -o Acquire::Retries=3 -o Acquire::http::Timeout=30 -o Acquire::https::Timeout=30"
-          $APT update
-          $APT install -y --no-install-recommends gdal-bin
-
       - uses: astral-sh/setup-uv@v6
         with:
           python-version: ${{ matrix.python }}

{bazis_cli-2.4.1 → bazis_cli-2.6.0}/.gitignore

@@ -42,3 +42,4 @@ my-*
 My*
 */**/_version.py
 /uv.lock
+eval-results/

bazis_cli-2.6.0/CLAUDE.md

@@ -0,0 +1,66 @@
+# bazis-cli
+
+The `bazis` command (`bazis new`, `bazis add`, `bazis audit`, `bazis change`): Claude Code through the
+Claude Agent SDK, run in a Bazis project with the MCP server bazis-mcp and the rules of
+Bazis (`bazis.contrib.mcp.rules.RULES`).
+
+- `bazis/contrib/cli/main.py` — the commands, with the tasks of `bazis.contrib.mcp.prompts`
+  (and the prompt of `bazis audit`);
+- `bazis/contrib/cli/agent.py` — the options of the agent (tools, permissions, MCP server),
+  the permission prompt in the terminal and the output. Of the tools of bazis-mcp only
+  those with `readOnlyHint` (read from the server it imports) are allowed in advance; the
+  others, for a client without a shell, a new one too, are never given to the agent, which
+  runs commands and edits files itself (`MCP_RULE` tells it that the instructions of the
+  server about them do not apply).
+
+The skeleton of a new project and its `.venv` (bazis-front in its requirements and apps
+unless `--no-frontend`, its languages: `--language`, else English until the agent sets the
+language of the description, the check of Node.js), the rules and the tasks of the agent
+are in bazis-mcp (`bazis.contrib.mcp.scaffold`, `rules`, `prompts`), with their tests.
+`--language` is checked by the Django of the Python of the CLI (bazis is its dependency),
+before anything is written.
+
+The frontend of a product is made by bazis-front (`manage.py bazis_front ...`) and read by
+the tools of bazis-mcp (`front_check`, `front_status`, `front_catalog`): bazis-cli only
+orders the work with the prompts (`prompts.FRONTEND_STEPS`) and rules
+(`rules.FRONTEND_RULES`) of bazis-mcp, it has no frontend code of its own.
+
+Commits, tags and pull requests are authored by the maintainer, Ilya Kharyn
+<ilya.tt07@gmail.com>, never by an AI assistant (see the CLAUDE.md of the core).
+
+## Running the tests
+
+The tests replace the Claude Agent SDK with a fake: they spend no credits and need no
+account; neither PostgreSQL nor Redis is needed:
+
+```bash
+python -m pytest tests -p no:cacheprovider
+```
+
+`evals/` builds projects with the real agent (`python -m evals.run --budget N`); its task
+with a frontend also needs Node.js and, before the release of bazis-front,
+`BAZIS_FRONT_REQUIREMENT`.
+
+Lint: `ruff check bazis tests evals`. A real run (`bazis audit --budget 0.5` in a project) spends
+credits of the Claude Code account: do it only when asked.
+
+## Releasing
+
+A release is the tag `vX.Y.Z` on `main`: the Build and Publish workflow builds the package
+(the version comes from the tag through setuptools-scm) and publishes it to PyPI
+(pre-releases `-alphaN`/`-betaN`/`-rcN` go to Test PyPI) and creates the GitHub release.
+
+Claude Code sessions cannot push tags. Release through the **Release** workflow instead:
+
+1. Make sure the changes are merged into `main` and the Tests workflow is green on the
+   `main` head commit (the Release workflow checks this and refuses otherwise).
+2. Add the release notes as `docs/releases/X.Y.Z.md` in the change being released.
+3. Start the workflow `release.yml` on `ref: main` with the input `version: X.Y.Z`
+   (GitHub API: `POST /repos/ecofuture-tech/bazis-cli/actions/workflows/release.yml/dispatches`;
+   with the GitHub MCP tools: `actions_run_trigger`, method `run_workflow`).
+4. The Release run creates the annotated tag and starts Build and Publish on it. Check
+   that both runs succeed and that the version appears on https://pypi.org/project/bazis-cli/.
+
+bazis-cli is released after bazis-mcp (and bazis-mcp after bazis-front). Pick the version by semver: breaking changes
+(commands or options renamed or removed) bump the minor version while the project is
+below 3.0.

bazis_cli-2.6.0/PKG-INFO

@@ -0,0 +1,153 @@
+Metadata-Version: 2.4
+Name: bazis-cli
+Version: 2.6.0
+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>
+License-Expression: Apache-2.0
+Project-URL: Home, https://github.com/ecofuture-tech/bazis-cli
+Keywords: bazis,django,fastapi,pydantic,framework,jsonapi,cli,ai,agents,claude
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Framework :: Django
+Classifier: Framework :: FastAPI
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: bazis>=2.16.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"
+Provides-Extra: dev
+Requires-Dist: ruff; extra == "dev"
+
+# bazis-cli
+
+The `bazis` command creates, extends and audits [Bazis](https://github.com/ecofuture-tech/bazis)
+projects with Claude. It runs Claude Code (the [Claude Agent SDK](https://code.claude.com/docs/en/agent-sdk))
+in the project with the MCP server [bazis-mcp](https://github.com/ecofuture-tech/bazis-mcp),
+so the agent chooses the Bazis packages from their catalog, follows their guides and checks
+the result with the system checks of the project instead of relying on its memory.
+
+## Installation
+
+```bash
+pip install bazis-cli      # or: uv tool install bazis-cli
+claude login               # or set ANTHROPIC_API_KEY
+```
+
+The agent uses the account of Claude Code and spends its credits; limit a run with
+`--budget`.
+
+## Commands
+
+```bash
+# a new product, backend and frontend, from a description
+bazis new shop "An online shop: products with categories, orders of users, \
+users see only their own orders"
+
+# only the backend
+bazis new shop "..." --no-frontend
+
+# a product in Russian (by default in the language of the description), always also in English
+bazis new shop "..." --language ru
+
+# a Bazis package for an existing project (run in the directory of manage.py)
+bazis add bazis-statusy "orders go through new -> paid -> shipped"
+
+# a review against the guides and checks of the packages; --fix also fixes
+bazis audit
+bazis audit --fix
+
+# go on changing the project, in the session of the last run of bazis in it
+bazis change "loans of rare books need an approval of a librarian"
+bazis change          # the changes typed one after another; an empty line ends
+```
+
+- `bazis new DIR DESCRIPTION` writes the skeleton of a project: the project package
+  (settings, root router, ASGI app), `project.env`, `.env` with a generated secret key,
+  `requirements.txt`, `requirements-dev.txt`, `tests/`, `.mcp.json` and `AGENTS.md`, and
+  chooses free ports for the servers of the project (`.bazis/ports.json`). It creates
+  `.venv` with Bazis and bazis-mcp (with uv if it is installed; `--no-venv` skips it),
+  raises the minimums of the requirements to the installed releases, and the database of `.env` with PostGIS when PostgreSQL is reachable (else it says
+  so and goes on; a database of that name with the data of another project is left as it
+  is, and the first free `<name>_N` is created and set in `.env` instead). Then the agent chooses the Bazis packages, creates the apps, models,
+  routes, migrations and tests, and runs the checks.
+- By default `bazis new` builds the whole product with its frontend, made by
+  [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 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
+  msgids of the code (`BS_LANGUAGES`, `BS_LANGUAGE_CODE`); `--language CODE` (a code of
+  Django such as `ru` or `pt-br`) chooses it instead. The texts of the backend are
+  translated in its gettext catalog and those of the screens in the dictionaries of the
+  frontend.
+- `bazis add PACKAGE [GOAL]` installs a Bazis package with the Bazis packages it requires
+  and sets them up as their guides say, in the frontend too when the project has one.
+  `bazis add bazis-front` builds the frontend of a backend.
+- `bazis audit [--fix]` reports the problems of the project by severity, with the checks
+  of the frontend when it has one. Without `--fix` the agent can only read.
+- `bazis change [REQUEST]` changes the project as the request says, in the session of
+  Claude Code of the last run of bazis in the project (`bazis new` prints the command):
+  the agent remembers what it built and what was asked before. Without a request the
+  changes are typed in the terminal one after another, each in the same session; an
+  empty line, `exit` or Ctrl-D ends, Ctrl-C stops the change that runs. `--new-session`
+  (or a session whose transcript is not on this machine) starts a new session, in which
+  the agent first learns the project. `--budget` limits every change.
+
+Every command writes the facts of its run (session, turns, cost, duration, tokens, calls
+of each tool) to `.bazis/run.json` of the project; `.bazis/` is never committed.
+
+Options of every command: `--project-dir` (`add`, `audit`, `change`; default: the current
+directory), `--model` (default `claude-opus-5-5`), `--effort` (`low` ... `max`, default
+`high`), `--budget USD`, `--yes`.
+
+## Permissions
+
+- The agent edits the files of the project directory without asking.
+- Everything else is shown in full and asked in the terminal: every shell command
+  (installing packages, migrations, tests), edits and reads outside the project, web access.
+  `y` allows it, `a` allows the rest of the run. `--yes` allows all of it; without a
+  terminal and without `--yes` it is denied.
+- The agent cannot read `.env` and cannot commit, push or reset with git: review the changes
+  and commit them yourself.
+- Only the settings of bazis-cli apply: the Claude Code settings, hooks and MCP servers of
+  the project and of the user are not loaded.
+- The agent calls only the tools of bazis-mcp that read (`readOnlyHint`: the catalog, the
+  guides, the facts and checks of the project, its files), without asking. Those for a
+  client without a shell, which run commands or change files, are not given to it, a tool
+  of a newer bazis-mcp that does not only read too: its commands and edits are those above.
+- `bazis audit` without `--fix` can only read the project and call the tools of bazis-mcp
+  that read. bazis-mcp runs the system checks of the project, that is the project code with
+  its `.venv`: run the commands only in projects you trust.
+
+The tests of a project need PostgreSQL with PostGIS and Redis (settings in `.env`); without
+them the agent creates the migrations and runs the system checks, and says that the tests
+did not run.
+
+The roles of a product are declared in `<app>/roles.py` and its statuses and transits in
+`<app>/workflow.py`; `migrate` applies them. The end-to-end tests of
+the frontend run against the backend with the test data of `python manage.py e2e_data`
+(the e2e data command recommended by bazis-front): the test users of the roles, with the
+password of `E2E_PASSWORD`, and the records the scenarios need, on the ports of
+`.bazis/ports.json` (`frontend/.env.local` sends `/api` to the backend with `BAZIS_API_URL`):
+
+```bash
+E2E_PASSWORD=... .venv/bin/python manage.py e2e_data
+.venv/bin/uvicorn shop.main:app --port <backend> &
+cd frontend && E2E_PORT=<e2e> E2E_PASSWORD=... npm run e2e
+```
+
+To try a bazis-front that is not on PyPI yet, point `BAZIS_FRONT_REQUIREMENT` to a wheel,
+a checkout or a URL: it replaces the requirement of bazis-front in `requirements.txt` of
+the new product, and uv builds it again instead of reusing the build of an older commit.

bazis_cli-2.6.0/README.md

@@ -0,0 +1,125 @@
+# bazis-cli
+
+The `bazis` command creates, extends and audits [Bazis](https://github.com/ecofuture-tech/bazis)
+projects with Claude. It runs Claude Code (the [Claude Agent SDK](https://code.claude.com/docs/en/agent-sdk))
+in the project with the MCP server [bazis-mcp](https://github.com/ecofuture-tech/bazis-mcp),
+so the agent chooses the Bazis packages from their catalog, follows their guides and checks
+the result with the system checks of the project instead of relying on its memory.
+
+## Installation
+
+```bash
+pip install bazis-cli      # or: uv tool install bazis-cli
+claude login               # or set ANTHROPIC_API_KEY
+```
+
+The agent uses the account of Claude Code and spends its credits; limit a run with
+`--budget`.
+
+## Commands
+
+```bash
+# a new product, backend and frontend, from a description
+bazis new shop "An online shop: products with categories, orders of users, \
+users see only their own orders"
+
+# only the backend
+bazis new shop "..." --no-frontend
+
+# a product in Russian (by default in the language of the description), always also in English
+bazis new shop "..." --language ru
+
+# a Bazis package for an existing project (run in the directory of manage.py)
+bazis add bazis-statusy "orders go through new -> paid -> shipped"
+
+# a review against the guides and checks of the packages; --fix also fixes
+bazis audit
+bazis audit --fix
+
+# go on changing the project, in the session of the last run of bazis in it
+bazis change "loans of rare books need an approval of a librarian"
+bazis change          # the changes typed one after another; an empty line ends
+```
+
+- `bazis new DIR DESCRIPTION` writes the skeleton of a project: the project package
+  (settings, root router, ASGI app), `project.env`, `.env` with a generated secret key,
+  `requirements.txt`, `requirements-dev.txt`, `tests/`, `.mcp.json` and `AGENTS.md`, and
+  chooses free ports for the servers of the project (`.bazis/ports.json`). It creates
+  `.venv` with Bazis and bazis-mcp (with uv if it is installed; `--no-venv` skips it),
+  raises the minimums of the requirements to the installed releases, and the database of `.env` with PostGIS when PostgreSQL is reachable (else it says
+  so and goes on; a database of that name with the data of another project is left as it
+  is, and the first free `<name>_N` is created and set in `.env` instead). Then the agent chooses the Bazis packages, creates the apps, models,
+  routes, migrations and tests, and runs the checks.
+- By default `bazis new` builds the whole product with its frontend, made by
+  [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 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
+  msgids of the code (`BS_LANGUAGES`, `BS_LANGUAGE_CODE`); `--language CODE` (a code of
+  Django such as `ru` or `pt-br`) chooses it instead. The texts of the backend are
+  translated in its gettext catalog and those of the screens in the dictionaries of the
+  frontend.
+- `bazis add PACKAGE [GOAL]` installs a Bazis package with the Bazis packages it requires
+  and sets them up as their guides say, in the frontend too when the project has one.
+  `bazis add bazis-front` builds the frontend of a backend.
+- `bazis audit [--fix]` reports the problems of the project by severity, with the checks
+  of the frontend when it has one. Without `--fix` the agent can only read.
+- `bazis change [REQUEST]` changes the project as the request says, in the session of
+  Claude Code of the last run of bazis in the project (`bazis new` prints the command):
+  the agent remembers what it built and what was asked before. Without a request the
+  changes are typed in the terminal one after another, each in the same session; an
+  empty line, `exit` or Ctrl-D ends, Ctrl-C stops the change that runs. `--new-session`
+  (or a session whose transcript is not on this machine) starts a new session, in which
+  the agent first learns the project. `--budget` limits every change.
+
+Every command writes the facts of its run (session, turns, cost, duration, tokens, calls
+of each tool) to `.bazis/run.json` of the project; `.bazis/` is never committed.
+
+Options of every command: `--project-dir` (`add`, `audit`, `change`; default: the current
+directory), `--model` (default `claude-opus-5-5`), `--effort` (`low` ... `max`, default
+`high`), `--budget USD`, `--yes`.
+
+## Permissions
+
+- The agent edits the files of the project directory without asking.
+- Everything else is shown in full and asked in the terminal: every shell command
+  (installing packages, migrations, tests), edits and reads outside the project, web access.
+  `y` allows it, `a` allows the rest of the run. `--yes` allows all of it; without a
+  terminal and without `--yes` it is denied.
+- The agent cannot read `.env` and cannot commit, push or reset with git: review the changes
+  and commit them yourself.
+- Only the settings of bazis-cli apply: the Claude Code settings, hooks and MCP servers of
+  the project and of the user are not loaded.
+- The agent calls only the tools of bazis-mcp that read (`readOnlyHint`: the catalog, the
+  guides, the facts and checks of the project, its files), without asking. Those for a
+  client without a shell, which run commands or change files, are not given to it, a tool
+  of a newer bazis-mcp that does not only read too: its commands and edits are those above.
+- `bazis audit` without `--fix` can only read the project and call the tools of bazis-mcp
+  that read. bazis-mcp runs the system checks of the project, that is the project code with
+  its `.venv`: run the commands only in projects you trust.
+
+The tests of a project need PostgreSQL with PostGIS and Redis (settings in `.env`); without
+them the agent creates the migrations and runs the system checks, and says that the tests
+did not run.
+
+The roles of a product are declared in `<app>/roles.py` and its statuses and transits in
+`<app>/workflow.py`; `migrate` applies them. The end-to-end tests of
+the frontend run against the backend with the test data of `python manage.py e2e_data`
+(the e2e data command recommended by bazis-front): the test users of the roles, with the
+password of `E2E_PASSWORD`, and the records the scenarios need, on the ports of
+`.bazis/ports.json` (`frontend/.env.local` sends `/api` to the backend with `BAZIS_API_URL`):
+
+```bash
+E2E_PASSWORD=... .venv/bin/python manage.py e2e_data
+.venv/bin/uvicorn shop.main:app --port <backend> &
+cd frontend && E2E_PORT=<e2e> E2E_PASSWORD=... npm run e2e
+```
+
+To try a bazis-front that is not on PyPI yet, point `BAZIS_FRONT_REQUIREMENT` to a wheel,
+a checkout or a URL: it replaces the requirement of bazis-front in `requirements.txt` of
+the new product, and uv builds it again instead of reusing the build of an older commit.

bazis_cli-2.6.0/bazis/contrib/cli/AGENTS.md

@@ -0,0 +1,89 @@
+# bazis-cli — guide for AI agents
+
+The command `bazis` creates, extends and audits Bazis projects with Claude: it runs Claude
+Code (Claude Agent SDK) in the project with the MCP server bazis-mcp and the rules of
+Bazis. It is a tool for the developer's machine, not a dependency of a project.
+
+## Commands
+
+- `bazis new DIR "what the product does"` writes the skeleton of a project (package with
+  settings, root router and ASGI app, `project.env`, `.env` with a generated secret key,
+  `requirements*.txt`, `tests/`, `.mcp.json`, `AGENTS.md`, `.bazis/ports.json` with free
+  ports of this machine for the backend, the dev server of the frontend and that of the
+  end-to-end tests), creates `.venv` with Bazis and bazis-mcp (`--no-venv` skips it), raises
+  the minimums of the requirements to the installed releases (`X.Y.Z`) and the database of the settings of the project (`.env`,
+  the `BS_DATABASES__DEFAULT__*` variables) with the extension PostGIS when PostgreSQL is
+  reachable and the database is missing (it says when it cannot, when PostGIS could not be
+  installed, and when an existing database has tables, probably of another project, and
+  goes on; the agent is told what it did), then the agent chooses the Bazis packages and builds the apps,
+  migrations and tests. By default the product also gets its frontend: bazis-front
+  is in `requirements.txt` and `BS_INSTALLED_APPS`, and the agent follows the order of the
+  guide of bazis-front (`bazis_front init`, the specs in `spec/`, the backend that
+  satisfies them with the roles, statuses and transits declared in `roles.py` and
+  `workflow.py` and the test users of `manage.py e2e_data`, migrate, `contract`, `check` until no errors, `add`, the
+  screens, `design`, `e2e` run against the backend, the final checks). It needs Node.js
+  22.12 or newer with npm (checked before anything is written); `--no-frontend` builds
+  only the backend. The product is in the language of the description (the agent sets
+  `BS_LANGUAGES` and `BS_LANGUAGE_CODE`) or of `--language CODE` (written by the
+  skeleton), and always in English: English msgids with `gettext_lazy`, the catalogs of
+  the project `locale/<language>/LC_MESSAGES/django.po` made, filled and compiled by
+  `manage.py bazis_messages` (`make`, the translations in `locale/translations.json`,
+  `apply`; a msgid of the packages that `bazis.W004` names declared with `gettext_noop` in
+  `<project>/translations.py` and translated so too), the texts of the screens through
+  `t()` of bazis-front, a `bazis.W005` reported. The `tests/conftest.py` of the
+  skeleton gives the cache keys of the tests a prefix of their own: the tests never flush
+  the shared Redis; the pytest plugin of bazis-test-utils installs the triggers of the test
+  database and `migrate` applies the declared roles and workflows, so it has no other
+  fixture.
+- `bazis add PACKAGE ["what for"]` installs a Bazis package and its Bazis dependencies and
+  sets them up as their guides say. In a project with a frontend
+  (`frontend/bazis-front.lock.json`) it then exports the contract, fixes `check`, copies
+  the components of the new capability and runs the final checks; `bazis add
+  bazis-front` builds the frontend of a backend.
+- `bazis audit [--fix]` reviews the project against the guides and checks of its packages
+  and, with a frontend, `front_check`, `front_status` and the guides of bazis-front;
+  without `--fix` the agent can only read (it lists the frontend commands it could not run).
+- `bazis change ["what to change"]` changes the project in the session of Claude Code of
+  the last run of bazis in it (`session_id` of `.bazis/run.json`, resumed when Claude Code
+  has its transcript on this machine), so the agent keeps what it built and was asked;
+  without a request the changes are typed in the terminal one after another, each in the
+  same session (an empty line, `exit` or Ctrl-D ends; Ctrl-C stops the running change and
+  keeps the session; without a terminal the request is needed). A new session
+  (`--new-session`, or none to resume) first reads `project_info` and the guides of the
+  packages concerned and, with a frontend, follows the steps of `bazis add`. A resumed
+  session gets the rules of the current run, and `--budget` limits each change.
+
+The agent reads the introduction of a guide and its sections when a step needs them, reads
+the sources of the packages only for a fact the guides lack, runs the final checks once
+(again only those that failed) and ends with a summary in fixed sections: Built, Packages,
+Run, Outside the files, Left for you, Guide gaps. The servers of a project use its ports
+of `.bazis/ports.json` (`frontend/.env.local` has `BAZIS_API_URL`), and its files go to
+`media/` and `static/` of the project (`BS_MEDIA_ROOT`, `BS_STATIC_ROOT` in `.env`).
+Every command writes the facts of its run to `.bazis/run.json`: the session, the turns, the
+cost (in a resumed session, that of the run, and `session_cost_usd` that of the session),
+the duration, the usage of the tokens and the calls of each tool. `.bazis/` ignores itself in
+Git.
+
+bazis-cli only orchestrates: the frontend logic (template, contract, specs, components,
+design, end-to-end tests) is in bazis-front and its `manage.py bazis_front` commands, the
+read-only tools in bazis-mcp (`front_check`, `front_status`, `front_catalog`); the CLI adds
+the order of the work, with the skeleton, the prompts and the rules of bazis-mcp
+(`bazis.contrib.mcp.scaffold`, `prompts`, `rules`). `BAZIS_FRONT_REQUIREMENT` (a path to a
+wheel or a checkout, or a URL) replaces the requirement of bazis-front in a new product, to
+try a version that is not on PyPI.
+
+Options: `--project-dir` (`add`, `audit`, `change`; default: the current directory), `--model` (default
+`claude-opus-5-5`), `--effort` (default `high`), `--budget USD`, `--yes` (run shell commands
+without asking).
+
+## Rules
+
+- Edits of the files of the project are accepted; every shell command and every other tool
+  call (edits or reads outside the project, web) is asked in the terminal (`a` allows the
+  rest of the run) unless `--yes`; without a terminal and `--yes` they are denied.
+- `.env` cannot be read; git cannot commit, push, reset or rebase: the user reviews and
+  commits the changes.
+- Only the MCP server bazis-mcp and no Claude Code settings of the project or the user are
+  loaded. The checks of bazis-mcp run the project code: use the commands in trusted
+  projects.
+- Credentials are those of Claude Code: `claude login` or `ANTHROPIC_API_KEY`.

{bazis_cli-2.4.1 → bazis_cli-2.6.0}/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.4.1'
-__version_tuple__ = version_tuple = (2, 4, 1)
+__version__ = version = '2.6.0'
+__version_tuple__ = version_tuple = (2, 6, 0)
 
-__commit_id__ = commit_id = 'g51fdae78c'
+__commit_id__ = commit_id = 'g04ed6b75d'