bazis-cli 2.4.0__py3-none-any.whl

bazis/contrib/cli/AGENTS.md

@@ -0,0 +1,33 @@
+# 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 project 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`), creates `.venv` with Bazis and
+  bazis-mcp (`--no-venv` skips it), then the agent chooses the Bazis packages and builds the
+  apps, migrations and tests.
+- `bazis add PACKAGE ["what for"]` installs a Bazis package and its Bazis dependencies and
+  sets them up as their guides say.
+- `bazis audit [--fix]` reviews the project against the guides and checks of its packages;
+  without `--fix` the agent can only read.
+
+Options: `--project-dir` (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/contrib/cli/__init__.py

@@ -0,0 +1,19 @@
+# Copyright 2026 EcoFuture Technology Services LLC and contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+try:
+    from importlib.metadata import PackageNotFoundError, version
+    __version__ = version('bazis-cli')
+except PackageNotFoundError:
+    __version__ = 'dev'

bazis/contrib/cli/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '2.4.0'
+__version_tuple__ = version_tuple = (2, 4, 0)
+
+__commit_id__ = commit_id = 'g2d504c4db'

bazis/contrib/cli/agent.py

@@ -0,0 +1,274 @@
+# Copyright 2026 EcoFuture Technology Services LLC and contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+The agent that does the work of a command: Claude Code (Claude Agent SDK) in the project
+directory, with the MCP server bazis-mcp of the project and the rules of Bazis.
+"""
+
+import json
+import re
+import sys
+import warnings
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import TextIO
+
+from claude_agent_sdk import (
+    AssistantMessage,
+    ClaudeAgentOptions,
+    HookMatcher,
+    PermissionResultAllow,
+    PermissionResultDeny,
+    ResultError,
+    ResultMessage,
+    TextBlock,
+    ToolUseBlock,
+    query,
+)
+from claude_agent_sdk.types import CanUseToolShadowedWarning
+
+
+DEFAULT_MODEL = 'claude-opus-5-5'
+DEFAULT_EFFORT = 'high'
+
+#: git commands that change the repository: the user commits, never the agent
+GIT_DENY = ['Bash(git commit:*)', 'Bash(git push:*)', 'Bash(git reset:*)', 'Bash(git rebase:*)']
+#: tools a review cannot use
+WRITE_TOOLS = ['Write', 'Edit', 'MultiEdit', 'NotebookEdit', 'Bash', 'WebFetch', 'WebSearch']
+GIT_COMMAND_RE = re.compile(r'(^|[;&|(]\s*)git\s+(commit|push|reset|rebase)\b', re.MULTILINE)
+
+RULES = """\
+# Bazis
+
+You work on a Bazis project in the current directory. Bazis builds JSON:API services on
+Django, FastAPI and Pydantic; the core is the package `bazis`, every other feature is a
+separate package `bazis-<name>`. A project installs only the packages it needs.
+
+- The MCP server `bazis` is the source of truth about Bazis, not your memory of it:
+  `list_packages` (what each package solves and requires), `package_guide` (how to use a
+  package, also `bazis` for the core), `project_info` (the installed packages, settings,
+  models and routes of this project) and `run_doctor` (the system checks). Read the guide
+  of every package before you use it and follow it exactly.
+- Read `AGENTS.md` (and `CLAUDE.md` if there is one) of the project first.
+- The Python environment is `.venv` (`.venv/bin/python`, on Windows
+  `.venv\\Scripts\\python.exe`). Add a package to `requirements.txt`, install it with
+  `.venv/bin/python -m pip install -r requirements.txt` and list its app in
+  `BS_INSTALLED_APPS` of `project.env` when its guide says so.
+- After changing models run `.venv/bin/python manage.py makemigrations`. After every change
+  run `run_doctor` and fix the errors and the warnings of the packages you used. Run the
+  tests with `.venv/bin/python -m pytest` when PostgreSQL and Redis are available (`.env`);
+  if they are not, say so instead of skipping the tests silently.
+- Write tests for the behavior you add (`tests/`), with `bazis_test_utils` as the guides show.
+- Never read, print or copy the values of `.env`. Never run git commands that change the
+  repository (commit, push, reset): the user reviews and commits the changes.
+- End with a short summary: what you built or changed, the Bazis packages used, how to run
+  it, and what is left for the user (for example the database).
+"""
+
+
+@dataclass
+class Task:
+    """
+    What the agent is asked to do in a project.
+    """
+
+    prompt: str
+    project_dir: Path
+    #: the agent may change files and run commands
+    writes: bool = True
+    model: str = DEFAULT_MODEL
+    effort: str = DEFAULT_EFFORT
+    max_budget_usd: float | None = None
+    #: run shell commands without asking
+    yes: bool = False
+    extra_rules: list[str] = field(default_factory=list)
+
+
+def mcp_server(project_dir: Path) -> dict:
+    """
+    The stdio MCP server bazis-mcp of the project, run with the Python of the CLI (it uses
+    `.venv` of the project for the project tools).
+    """
+    return {
+        'type': 'stdio',
+        'command': sys.executable,
+        'args': ['-m', 'bazis.contrib.mcp.server', '--project-dir', str(project_dir)],
+    }
+
+
+def _path_rule(tool: str, path: Path) -> str:
+    """
+    A permission rule for an absolute path (`//` starts an absolute path in the rules).
+    """
+    return f'{tool}(//{path.resolve().as_posix().lstrip("/")})'
+
+
+def options(task: Task, asker: 'Asker | None' = None) -> ClaudeAgentOptions:
+    """
+    The options of the agent for a task. Only the MCP server bazis-mcp of the CLI is used
+    (`strict_mcp_config`) and no settings of the project or the user are loaded, so the
+    permissions below are the only ones.
+
+    A read-only task can only read the project and call the MCP tools. A task that writes
+    gets the edits of files in the project accepted (`acceptEdits`); everything else is
+    asked: shell commands through a PreToolUse hook (the CLI would otherwise allow commands
+    such as `rm` or `sed` in `acceptEdits` mode), the other tools through `can_use_tool`.
+    In both, `.env` cannot be read and git cannot change the repository.
+    """
+    rules = '\n'.join([RULES, *task.extra_rules])
+    secrets = [_path_rule(tool, task.project_dir / '.env') for tool in ('Read', 'Edit')]
+    common = dict(
+        cwd=str(task.project_dir),
+        model=task.model,
+        effort=task.effort,
+        max_budget_usd=task.max_budget_usd,
+        mcp_servers={'bazis': mcp_server(task.project_dir)},
+        strict_mcp_config=True,
+        setting_sources=[],
+        system_prompt={'type': 'preset', 'preset': 'claude_code', 'append': rules},
+        allowed_tools=['mcp__bazis'],
+    )
+    if not task.writes:
+        return ClaudeAgentOptions(
+            disallowed_tools=[*WRITE_TOOLS, *secrets],
+            permission_mode='dontAsk',
+            **common,
+        )
+    asker = asker or Asker(task.yes)
+    return ClaudeAgentOptions(
+        disallowed_tools=[*GIT_DENY, *secrets],
+        permission_mode='acceptEdits',
+        can_use_tool=asker.can_use_tool,
+        hooks={'PreToolUse': [HookMatcher(matcher='Bash', hooks=[asker.bash_hook])]},
+        **common,
+    )
+
+
+class Asker:
+    """
+    Asks the user in the terminal before the tools that are not allowed in advance: `y`
+    allows the call, `a` allows the rest of the run. With `yes` everything is allowed;
+    without a terminal everything is denied. Commands that change the git repository are
+    always denied.
+    """
+
+    def __init__(self, yes: bool, stdin: TextIO | None = None, out: TextIO | None = None):
+        self.allow_all = yes
+        self.stdin = stdin or sys.stdin
+        self.out = out or sys.stderr
+
+    def decide(self, tool_name: str, tool_input: dict) -> str | None:
+        """
+        None if allowed, else the reason of the denial.
+        """
+        command = tool_input.get('command', '') if tool_name == 'Bash' else ''
+        if GIT_COMMAND_RE.search(command):
+            return 'The user commits the changes: git commands that change the repository are not allowed.'
+        if self.allow_all:
+            return None
+        if not self.stdin.isatty():
+            return 'Not allowed: no terminal to ask the user (run bazis with --yes to allow).'
+        details = command or json.dumps(tool_input, ensure_ascii=False, indent=2)
+        why = tool_input.get('description')
+        self.out.write(f'\n? {tool_name}' + (f' — {why}' if why else '') + '\n')
+        self.out.write(''.join(f'    {line}\n' for line in details.splitlines()))
+        self.out.write('  allow [y/N/a=all]: ')
+        self.out.flush()
+        answer = self.stdin.readline().strip().lower()
+        if answer == 'a':
+            self.allow_all = True
+        if answer in ('y', 'yes', 'a'):
+            return None
+        return 'The user did not allow it.'
+
+    async def can_use_tool(self, tool_name: str, tool_input: dict, context) -> object:
+        reason = self.decide(tool_name, tool_input)
+        if reason is None:
+            return PermissionResultAllow()
+        return PermissionResultDeny(message=reason)
+
+    async def bash_hook(self, hook_input: dict, tool_use_id, context) -> dict:
+        reason = self.decide('Bash', hook_input.get('tool_input', {}))
+        return {
+            'hookSpecificOutput': {
+                'hookEventName': 'PreToolUse',
+                'permissionDecision': 'allow' if reason is None else 'deny',
+                'permissionDecisionReason': reason or 'Allowed by the user.',
+            }
+        }
+
+
+def describe(tool_name: str, tool_input: dict) -> str:
+    """
+    One line about a tool call, for the progress output.
+    """
+    for key in ('command', 'file_path', 'path', 'pattern', 'url', 'name'):
+        if value := tool_input.get(key):
+            lines = str(value).splitlines()
+            more = ' ...' if len(lines) > 1 else ''
+            return lines[0][:200] + more
+    return ''
+
+
+def render(message, out: TextIO | None = None) -> ResultMessage | None:
+    """
+    Prints the text of the agent and one line per tool call; returns the final result.
+    """
+    out = out or sys.stdout
+    if isinstance(message, AssistantMessage):
+        for block in message.content:
+            if isinstance(block, TextBlock) and block.text.strip():
+                out.write(block.text.rstrip() + '\n')
+            elif isinstance(block, ToolUseBlock):
+                name = block.name.removeprefix('mcp__bazis__')
+                out.write(f'  > {name} {describe(block.name, block.input)}'.rstrip() + '\n')
+        out.flush()
+    elif isinstance(message, ResultMessage):
+        return message
+    return None
+
+
+async def run(task: Task, out: TextIO | None = None) -> ResultMessage | None:
+    """
+    Runs the task and prints the progress; returns the final result of the agent.
+    """
+    result = None
+    # the read-only MCP tools of bazis-mcp are allowed in advance on purpose
+    warnings.filterwarnings('ignore', category=CanUseToolShadowedWarning)
+    try:
+        async for message in query(prompt=task.prompt, options=options(task)):
+            result = render(message, out) or result
+    except ResultError:
+        # the CLI exits with an error after a failed result (e.g. the budget is spent):
+        # the result says why
+        if result is None:
+            raise
+    return result
+
+
+def error_text(result: ResultMessage) -> str:
+    """
+    Why a run failed.
+    """
+    reasons = {
+        'error_max_budget_usd': 'the budget (--budget) is spent',
+        'error_max_turns': 'the agent reached the maximum number of turns',
+    }
+    return (
+        '; '.join(result.errors or [])
+        or reasons.get(result.subtype)
+        or result.result
+        or result.subtype
+    )

bazis/contrib/cli/bazis_manifest.toml

@@ -0,0 +1,32 @@
+# What the package is for and how to use it, for tools and AI agents (see AGENTS.md).
+# `import` paths and `check` ids are verified by tests/test_cli.py.
+
+[package]
+name = "bazis-cli"
+summary = "the bazis command: creates, extends and audits Bazis projects with Claude"
+solves = [
+    "create a Bazis project from a description of what it does",
+    "add a Bazis package to a project and set it up",
+    "review a project against the guides and checks of its Bazis packages",
+]
+requires = ["bazis-mcp"]
+pairs_well = []
+
+[[extension_points]]
+name = "bazis"
+import = "bazis.contrib.cli.main.main"
+use_when = "the command line entry point"
+
+[[extension_points]]
+name = "Task"
+import = "bazis.contrib.cli.agent.Task"
+use_when = "run the agent of a command from Python (bazis.contrib.cli.agent.run)"
+
+[[pitfalls]]
+text = "the agent spends API credits of the account of Claude Code; limit a run with --budget"
+
+[[pitfalls]]
+text = "the system checks run the project code with its .venv, also in a read-only audit: use bazis in trusted projects"
+
+[[pitfalls]]
+text = "the tests of a new project need PostgreSQL with PostGIS and Redis (.env); without them the agent only checks and migrates"

bazis/contrib/cli/main.py

@@ -0,0 +1,180 @@
+# Copyright 2026 EcoFuture Technology Services LLC and contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+The `bazis` command:
+
+- `bazis new DIR "what the project does"` creates a project and builds it;
+- `bazis add PACKAGE [what for]` adds a Bazis package to the project;
+- `bazis audit [--fix]` reviews the project against the guides and checks of its packages.
+"""
+
+import argparse
+import asyncio
+import sys
+from pathlib import Path
+
+from claude_agent_sdk import ClaudeSDKError, CLIConnectionError
+
+from . import __version__, agent, scaffold
+
+
+def new_task(args) -> agent.Task:
+    directory = args.directory.resolve()
+    name = args.name or scaffold.package_name(directory)
+    scaffold.write_files(directory, name)
+    print(f'Created the project {name} in {directory}')
+    if not args.no_venv:
+        print('Installing the dependencies into .venv ...')
+        try:
+            scaffold.create_venv(directory)
+        except scaffold.ScaffoldError as err:
+            raise scaffold.ScaffoldError(
+                f'{err}\nThe files of the project are written: create .venv and install '
+                f'requirements-dev.txt by hand, or delete {directory} and run bazis new again.'
+            ) from err
+    prompt = f"""\
+Build this Bazis project: {args.description}
+
+The skeleton is ready: the project package `{name}` (settings, root router, ASGI app in
+`{name}/main.py`), `project.env`, `.env`, `requirements.txt`, `tests/`, and `.venv` with
+Bazis installed. Read the guide of the core (`package_guide("bazis")`), choose the Bazis
+packages the project needs with `list_packages`, read their guides, then create the apps
+with their models, routes and tests, and register the routers in `{name}/router.py`.
+"""
+    return _task(args, prompt, directory)
+
+
+def add_task(args) -> agent.Task:
+    goal = f' The project needs it for: {args.goal}' if args.goal else ''
+    prompt = f"""\
+Add the Bazis package {args.package} to this project and use it.{goal}
+
+Read its guide with `package_guide("{args.package}")` and the guides of the Bazis packages
+it requires that are not installed (`list_packages`), install them, follow the setup of the
+guides, change the models and routes they concern, create the migrations, add tests, and
+make `run_doctor` pass without the warnings of the new packages.
+"""
+    return _task(args, prompt, args.project_dir.resolve())
+
+
+def audit_task(args) -> agent.Task:
+    if args.fix:
+        action = 'Then fix the problems you are sure about and run the checks and the tests again.'
+    else:
+        action = 'Change nothing: this is a review.'
+    prompt = f"""\
+Audit this Bazis project.
+
+1. Run `run_doctor` with `deploy=true` and `project_info`.
+2. For every installed Bazis package read `package_guide` and compare the project with its
+   rules and pitfalls: routes that bypass permissions or the update checks, settings that
+   are unsafe in production, packages that are installed but not used, needs that a Bazis
+   package solves but the project implements by hand, missing tests and migrations.
+3. Report the problems ordered by severity, each with the file, the reason and the fix.
+
+{action}
+"""
+    return _task(args, prompt, args.project_dir.resolve(), writes=args.fix)
+
+
+def _task(args, prompt: str, project_dir: Path, writes: bool = True) -> agent.Task:
+    return agent.Task(
+        prompt=prompt,
+        project_dir=project_dir,
+        writes=writes,
+        model=args.model,
+        effort=args.effort,
+        max_budget_usd=args.budget,
+        yes=args.yes,
+    )
+
+
+def parser() -> argparse.ArgumentParser:
+    common = argparse.ArgumentParser(add_help=False)
+    common.add_argument('--model', default=agent.DEFAULT_MODEL, help='Default: %(default)s.')
+    common.add_argument(
+        '--effort', default=agent.DEFAULT_EFFORT,
+        choices=['low', 'medium', 'high', 'xhigh', 'max'], help='Default: %(default)s.',
+    )
+    common.add_argument('--budget', type=float, help='Stop after spending this many USD.')
+    common.add_argument(
+        '--yes', '-y', action='store_true',
+        help='Allow shell commands and the other tools without asking (edits of the files of '
+        'the project are always allowed; git cannot commit, push or reset).',
+    )
+
+    project = argparse.ArgumentParser(add_help=False)
+    project.add_argument(
+        '--project-dir', type=Path, default=Path.cwd(),
+        help='The directory of manage.py (default: the current directory).',
+    )
+
+    root = argparse.ArgumentParser(
+        prog='bazis', description='Builds and audits Bazis projects with Claude.'
+    )
+    root.add_argument('--version', action='version', version=f'%(prog)s {__version__}')
+    commands = root.add_subparsers(dest='command', required=True)
+
+    new = commands.add_parser('new', parents=[common], help='Create and build a project.')
+    new.add_argument('directory', type=Path, help='A new or empty directory.')
+    new.add_argument('description', help='What the project does, in your words.')
+    new.add_argument('--name', help='The project package (default: from the directory name).')
+    new.add_argument('--no-venv', action='store_true', help='Do not create .venv.')
+    new.set_defaults(make_task=new_task)
+
+    add = commands.add_parser('add', parents=[common, project], help='Add a Bazis package.')
+    add.add_argument('package', help='The package, e.g. bazis-permit.')
+    add.add_argument('goal', nargs='?', help='What the project needs it for.')
+    add.set_defaults(make_task=add_task)
+
+    audit = commands.add_parser('audit', parents=[common, project], help='Review the project.')
+    audit.add_argument('--fix', action='store_true', help='Also fix the problems.')
+    audit.set_defaults(make_task=audit_task)
+    return root
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = parser().parse_args(argv)
+    try:
+        task = args.make_task(args)
+    except scaffold.ScaffoldError as err:
+        print(f'bazis: {err}', file=sys.stderr)
+        return 1
+    try:
+        result = asyncio.run(agent.run(task))
+    except ClaudeSDKError as err:
+        print(f'bazis: {err}', file=sys.stderr)
+        if isinstance(err, CLIConnectionError) or 'auth' in str(err).lower():
+            print(
+                'The agent runs Claude Code: sign in with `claude login` or set '
+                'ANTHROPIC_API_KEY.',
+                file=sys.stderr,
+            )
+        return 1
+    except KeyboardInterrupt:
+        return 130
+    if result is None:
+        print('bazis: the agent ended without a result', file=sys.stderr)
+        return 1
+    cost = f', ${result.total_cost_usd:.2f}' if result.total_cost_usd is not None else ''
+    print(f'\n[{result.num_turns} turns{cost}]', file=sys.stderr)
+    if result.is_error:
+        print(f'bazis: {agent.error_text(result)}', file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

bazis/contrib/cli/scaffold.py

@@ -0,0 +1,273 @@
+# Copyright 2026 EcoFuture Technology Services LLC and contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+The skeleton of a new Bazis project: the files every project has, written without the
+model, and its virtual environment. The agent then adds the apps the project needs.
+"""
+
+import importlib.util
+import json
+import keyword
+import re
+import secrets
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+
+#: the packages of every project; the agent adds the Bazis packages the project needs
+REQUIREMENTS = ['bazis>=2.4.1']
+REQUIREMENTS_DEV = ['bazis-mcp>=2.4.1', 'bazis-test-utils>=2.4.0']
+
+
+MANAGE_PY = '''#!/usr/bin/env python
+import os
+import sys
+
+
+def main():
+    os.environ.setdefault('DJANGO_SETTINGS_MODULE', '{name}.settings')
+    from django.core.management import execute_from_command_line
+
+    execute_from_command_line(sys.argv)
+
+
+if __name__ == '__main__':
+    main()
+'''
+
+SETTINGS_PY = '''# Settings are environment variables with the BS_ prefix (project.env, .env):
+# bazis.core.configure builds the Django settings from them.
+import bazis.core.configure  # noqa: F401
+'''
+
+MAIN_PY = '''import os
+
+
+os.environ.setdefault('DJANGO_SETTINGS_MODULE', '{name}.settings')
+
+from bazis.core.app import app  # noqa: E402, F401
+'''
+
+ROUTER_PY = '''from bazis.core.routing import BazisRouter
+
+
+router = BazisRouter(prefix='/api/v1')
+# register the routers of the apps: router.register('<app>.router')
+'''
+
+URLS_PY = '''from django.conf import settings
+from django.contrib import admin
+from django.urls import path, re_path
+from django.views.static import serve
+
+
+urlpatterns = [
+    path('admin/', admin.site.urls),
+]
+
+if settings.DEBUG:
+    urlpatterns += [
+        re_path(r'^media/(?P<path>.*)$', serve, dict(document_root=settings.MEDIA_ROOT)),
+        re_path(r'^static/(?P<path>.*)$', serve, dict(document_root=settings.STATIC_ROOT)),
+    ]
+'''
+
+WSGI_PY = '''import os
+
+from django.core.wsgi import get_wsgi_application
+
+
+os.environ.setdefault('DJANGO_SETTINGS_MODULE', '{name}.settings')
+
+application = get_wsgi_application()
+'''
+
+TEMPLATES = [
+    {
+        'BACKEND': 'django.template.backends.django.DjangoTemplates',
+        'DIRS': ['__BASE_DIR__/templates'],
+        'APP_DIRS': True,
+        'OPTIONS': {
+            'context_processors': [
+                'django.template.context_processors.debug',
+                'django.template.context_processors.request',
+                'django.contrib.auth.context_processors.auth',
+                'django.contrib.messages.context_processors.messages',
+            ]
+        },
+    }
+]
+
+PROJECT_ENV = '''# Settings of the project shared by all environments (secrets go to .env)
+BS_INSTALLED_APPS='[]'
+BS_ROOT_URLCONF={name}.urls
+BS_BAZIS_ROUTER_MODULE={name}.router
+BS_WSGI_APPLICATION={name}.wsgi.application
+BS_DEFAULT_AUTO_FIELD=django.db.models.BigAutoField
+BS_LANGUAGE_CODE=en
+BS_TEMPLATES='{templates}'
+'''
+
+DOT_ENV = '''# Local settings and secrets of this environment; not committed
+BS_DEBUG=true
+BS_SECRET_KEY={secret_key}
+BS_DATABASES__DEFAULT__HOST=localhost
+BS_DATABASES__DEFAULT__PORT=5432
+BS_DATABASES__DEFAULT__NAME={name}
+BS_DATABASES__DEFAULT__USER=postgres
+BS_DATABASES__DEFAULT__PASSWORD=postgres
+BS_CACHES__DEFAULT__LOCATION=redis://localhost:6379/0
+'''
+
+GITIGNORE = '''.env
+.venv/
+__pycache__/
+*.pyc
+.pytest_cache/
+media/
+static/
+'''
+
+PYTEST_INI = '''[pytest]
+DJANGO_SETTINGS_MODULE = {name}.settings
+'''
+
+CONFTEST_PY = '''import pytest
+
+
+@pytest.fixture
+def app():
+    from {name}.main import app
+
+    return app
+'''
+
+WINDOWS = sys.platform == 'win32'
+VENV_BIN = '.venv/Scripts' if WINDOWS else '.venv/bin'
+EXE = '.exe' if WINDOWS else ''
+
+AGENTS_MD = '''# {name}
+
+A [Bazis](https://github.com/ecofuture-tech/bazis) project: JSON:API services on Django,
+FastAPI and Pydantic.
+
+- The Python environment is `.venv`; the dependencies are in `requirements.txt` and
+  `requirements-dev.txt` (install them with `.venv/bin/python -m pip install -r ...`).
+- Settings are `BS_*` variables: shared ones in `project.env`, local ones and secrets in
+  `.env` (not committed). Apps, including Bazis packages, are listed in `BS_INSTALLED_APPS`.
+- The MCP server `bazis` (`.mcp.json`) gives the catalog and the guides of the Bazis
+  packages and the facts and checks of this project. Read the guide of a package before
+  using it, and run `python manage.py bazis_doctor` and the tests after every change.
+- PostgreSQL with PostGIS and Redis are required to run the project and the tests
+  (`.env`); the checks and `makemigrations` work without them.
+'''
+
+
+class ScaffoldError(Exception):
+    pass
+
+
+def package_name(directory: Path) -> str:
+    """
+    The name of the project package: the directory name as a Python identifier that does
+    not hide a module (`django`, `json`) or the tests.
+    """
+    name = re.sub(r'\W+', '_', directory.name.lower()).strip('_')
+    if not name or name[0].isdigit():
+        name = f'project_{name}'.rstrip('_')
+    if not valid_package_name(name):
+        name = f'{name}_project'
+    return name
+
+
+def valid_package_name(name: str) -> bool:
+    return (
+        name.isidentifier()
+        and not keyword.iskeyword(name)
+        and name not in ('tests', 'test')
+        and importlib.util.find_spec(name) is None
+    )
+
+
+def write_files(directory: Path, name: str) -> list[Path]:
+    """
+    Writes the skeleton of the project. Fails if the directory has files already.
+    """
+    if directory.exists() and any(directory.iterdir()):
+        raise ScaffoldError(f'{directory} is not empty')
+    if not valid_package_name(name):
+        raise ScaffoldError(
+            f'{name!r} cannot be the project package: it must be an identifier that is not '
+            'a keyword, "tests" or the name of an installed module'
+        )
+    files = {
+        'manage.py': MANAGE_PY.format(name=name),
+        f'{name}/__init__.py': '',
+        f'{name}/settings.py': SETTINGS_PY,
+        f'{name}/main.py': MAIN_PY.format(name=name),
+        f'{name}/router.py': ROUTER_PY,
+        f'{name}/urls.py': URLS_PY,
+        f'{name}/wsgi.py': WSGI_PY.format(name=name),
+        'project.env': PROJECT_ENV.format(name=name, templates=json.dumps(TEMPLATES)),
+        '.env': DOT_ENV.format(name=name, secret_key=secrets.token_urlsafe(48)),
+        '.gitignore': GITIGNORE,
+        'requirements.txt': '\n'.join(REQUIREMENTS) + '\n',
+        'requirements-dev.txt': '-r requirements.txt\n' + '\n'.join(REQUIREMENTS_DEV) + '\n',
+        'pytest.ini': PYTEST_INI.format(name=name),
+        'tests/__init__.py': '',
+        'tests/conftest.py': CONFTEST_PY.format(name=name),
+        '.mcp.json': json.dumps(
+            {'mcpServers': {'bazis': {'command': f'{VENV_BIN}/bazis-mcp{EXE}', 'args': []}}},
+            indent=2,
+        ) + '\n',
+        'AGENTS.md': AGENTS_MD.format(name=name),
+    }
+    written = []
+    for relative, content in files.items():
+        path = directory / relative
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(content, encoding='utf-8')
+        written.append(path)
+    return written
+
+
+def create_venv(directory: Path, run=subprocess.run) -> Path:
+    """
+    Creates `.venv` with the dependencies of the project (with uv if it is installed) and
+    returns its Python.
+    """
+    venv = directory / '.venv'
+    python = venv / ('Scripts/python.exe' if sys.platform == 'win32' else 'bin/python')
+    uv = shutil.which('uv')
+    if uv:
+        commands = [
+            # --seed installs pip, which the agent uses to add packages
+            [uv, 'venv', '--quiet', '--seed', '--python', sys.executable, str(venv)],
+            [uv, 'pip', 'install', '--quiet', '--python', str(python),
+             '-r', str(directory / 'requirements-dev.txt')],
+        ]
+    else:
+        commands = [
+            [sys.executable, '-m', 'venv', str(venv)],
+            [str(python), '-m', 'pip', 'install', '--quiet',
+             '-r', str(directory / 'requirements-dev.txt')],
+        ]
+    for command in commands:
+        done = run(command, cwd=directory, capture_output=True, text=True)
+        if done.returncode:
+            raise ScaffoldError(f'{" ".join(command)} failed:\n{done.stderr.strip()[-2000:]}')
+    return python

bazis_cli-2.4.0.dist-info/METADATA

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: bazis-cli
+Version: 2.4.0
+Summary: The bazis command: creates, extends and audits Bazis projects 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-mcp>=2.4.1
+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 project from a description
+bazis new shop "An online shop: products with categories, orders of users, \
+users see only their own orders"
+
+# 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
+```
+
+- `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`. It
+  creates `.venv` with Bazis and bazis-mcp (with uv if it is installed; `--no-venv` skips
+  it). Then the agent chooses the Bazis packages, creates the apps, models, routes,
+  migrations and tests, and runs the checks.
+- `bazis add PACKAGE [GOAL]` installs a Bazis package with the Bazis packages it requires
+  and sets them up as their guides say.
+- `bazis audit [--fix]` reports the problems of the project by severity. Without `--fix`
+  the agent can only read.
+
+Options of every command: `--project-dir` (`add`, `audit`; 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.
+- `bazis audit` without `--fix` can only read the project and call bazis-mcp. 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.

bazis_cli-2.4.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+bazis/contrib/cli/AGENTS.md,sha256=mgBQ_Sr0GqLMoY3WVqGLYgc7XGl1K1B5_k9Qk5QpsKE,1802
+bazis/contrib/cli/__init__.py,sha256=OYHBOe-gKbJL9WElLNLkYKhNZB6Sa2G19oNVnjBo-T4,777
+bazis/contrib/cli/_version.py,sha256=9x8v3jtROsCpS8s3YKlkPGuPEcXwPyPiZdq4RuGDXMo,528
+bazis/contrib/cli/agent.py,sha256=hUbqyhVOZkF65TJGaVtj9jlRsu5n_S7z1HAIxiydt8M,10851
+bazis/contrib/cli/bazis_manifest.toml,sha256=4iZKcXoy_AQpyafGgHeEERPyeC4gsY9lWxFMgjPTZiw,1184
+bazis/contrib/cli/main.py,sha256=TmT1Lrt2vhdIa2DvAgkDYmK5LAIW5Jiqoz9N2t9SNUs,7391
+bazis/contrib/cli/scaffold.py,sha256=VBGQkH86W5os-67hUB5l_Gn0Xw6DbNCwlT9HTayzuiQ,8708
+bazis_cli-2.4.0.dist-info/METADATA,sha256=gaikRaAC6qdYo3I7q8d1R6-K7BC39igFNJgb1ZajlEc,4259
+bazis_cli-2.4.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+bazis_cli-2.4.0.dist-info/entry_points.txt,sha256=M5dr9d744jnX9cWly8Vsrzvoxb46kDpiaokM8VmACdU,54
+bazis_cli-2.4.0.dist-info/top_level.txt,sha256=WgdrPZTZBMG8i_EqxA3vU5qI4ETQ_RsqKqSqsfIApHY,6
+bazis_cli-2.4.0.dist-info/RECORD,,

bazis_cli-2.4.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

bazis_cli-2.4.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+bazis = bazis.contrib.cli.main:main

bazis_cli-2.4.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+bazis