karni-cli 0.3.1__tar.gz → 0.4.0__tar.gz

{karni_cli-0.3.1 → karni_cli-0.4.0}/.gitignore

@@ -19,6 +19,7 @@ packages/karni-cli/karni_cli/_templates/
 packages/karni-cli/karni_cli/_agent/
 packages/karni-cli/karni_cli/_changelog/
 packages/karni-cli/karni_cli/_errorcodes/
+packages/karni-cli/karni_cli/_ui/
 
 # Node
 node_modules/

{karni_cli-0.3.1 → karni_cli-0.4.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.5
 Name: karni-cli
-Version: 0.3.1
-Summary: The karni command for the Karni Django + React framework: scaffold a project, generate models, viewsets and pages, run it, upgrade it across releases, and give AI coding agents its context, rules and error explanations.
+Version: 0.4.0
+Summary: The karni command: scaffold, generate, run and upgrade Karni projects. Karni is an open-source Django + React framework for building with AI coding agents. Your agent writes only your domain. The API, admin, permissions and React screens come from a package you upgrade, not code it rewrites in each project. One rule set covers Claude Code, Cursor and Copilot. The build fails when an agent hand-writes what Karni ships.
 Project-URL: Homepage, https://github.com/cbsshekhawat18-lab/karni
 Project-URL: Documentation, https://cbsshekhawat18-lab.github.io/karni/
 Project-URL: Repository, https://github.com/cbsshekhawat18-lab/karni
@@ -38,66 +38,73 @@ Description-Content-Type: text/markdown
 
 # karni-cli
 
-The `karni` command. Orchestrates a Karni project's own `manage.py` via
-subprocess — the CLI itself never imports Django.
+The `karni` command. It runs a Karni project's own `manage.py` as a
+subprocess, so the CLI itself never imports Django.
 
 ## Commands
-- `karni new <name>` — scaffold a project from the bundled cookiecutter
-  template (monorepo checkouts use the live `templates/project`; override with
-  `KARNI_TEMPLATES`).
-- `karni add <module>` — add `karni-<module>` to `[project].dependencies` and
+- `karni new <name>`: scaffold a project from the bundled cookiecutter
+  template. Monorepo checkouts use the live `templates/project`, and
+  `KARNI_TEMPLATES` overrides it.
+- `karni add <module>`: add `karni-<module>` to `[project].dependencies` and
   wire `karni_<module>` into the `# karni:apps` block in config/settings.py.
-  Only that marker block is managed; any other layout gets a clear error and
+  Only that marker block is managed. Any other layout gets a clear error, and
   you edit settings manually.
   Once the module is installed it also records the module's
   `AGENTS.fragment.md` as `.karni/modules/<module>.md` and refreshes the agent
   adapters.
-- `karni types` — dump the OpenAPI schema (`manage.py spectacular`), generate
+- `karni types`: dump the OpenAPI schema (`manage.py spectacular`), generate
   `types.ts` (openapi-typescript, project-pinned binary preferred, else
   `npx openapi-typescript@^7`) and typed hooks (`hooks.ts`) over @karni/ui.
-- `karni context` — compact machine-readable inventory (< 200 tokens for a
-  typical project): APPS (from the `# karni:apps` block) and PAGES (from
-  `frontend/src/pages/`) read statically, MODELS/VIEWSETS from `manage.py karni_context`,
-  COMPONENTS/HOOKS from @karni/ui's build-generated `dist/manifest.json`
-  (omitted when absent — run `npm i @karni/ui` in `frontend/` on the host to
-  enable them; `--manifest PATH` overrides). Nothing is hand-maintained.
-- `karni context --with-history [PATH]` — the same inventory plus a
+- `karni ui detect`: map the frontend's design system (shadcn/ui, a Tailwind
+  theme, Material UI, Chakra UI or Mantine) onto @karni/ui's `--karni-*`
+  tokens in `karni-theme.css`, plus `karni-primitives.tsx` for shadcn/ui.
+  `--dry-run` previews, `--json` reports for agents, and edited files are kept
+  unless `--force`.
+- `karni context`: a compact machine-readable inventory (< 200 tokens for a
+  typical project). APPS (from the `# karni:apps` block) and PAGES (from
+  `frontend/src/pages/`) are read statically, MODELS/VIEWSETS come from `manage.py karni_context`,
+  and COMPONENTS/HOOKS from @karni/ui's build-generated `dist/manifest.json`.
+  Those two are omitted when the manifest is absent. Run `npm i @karni/ui` in
+  `frontend/` on the host to enable them, or override with `--manifest PATH`.
+  Nothing is hand-maintained.
+- `karni context --with-history [PATH]`: the same inventory plus a
   `HISTORY:` brief of what was already asked and decided about PATH (without
   PATH: the project's recorded decisions) from any history provider that
   detects a store, e.g. Gigai Chronicle's `.chronicle/`. Capped at ~300
   tokens (characters ÷ 4), cut at line boundaries with a last line naming the
   full-brief command. With no store the output is exactly `karni context`'s.
   See `docs/concepts/history-providers.md`.
-- `karni check [-q]` — Django system checks plus `karni.checks` entry-point hooks
+- `karni check [-q]`: Django system checks plus `karni.checks` entry-point hooks
   (the architecture-test extension surface). A clean run outside CI may end
-  with one tip on stderr, at most once per project; `-q` suppresses it.
-- `karni doctor [-q]` — human-readable environment report: project,
-  interpreter (`.venv` / compose service), Node/npm, the @karni/ui manifest,
-  adapter freshness, history providers. May end with the same one-time tip.
-- `karni config get|set|list [--global] KEY [VALUE]` — settings
-  (`suggest_tools`): `.karni/config.toml` in the project (committed) or
-  `$XDG_CONFIG_HOME/karni/config.toml` with `--global`; the project wins.
+  with one tip on stderr, at most once per project. `-q` suppresses it.
+- `karni doctor [-q]`: a human-readable environment report covering the
+  project, interpreter (`.venv` / compose service), Node/npm, the @karni/ui
+  manifest, adapter freshness and history providers. It may end with the same
+  one-time tip.
+- `karni config get|set|list [--global] KEY [VALUE]`: settings
+  (`suggest_tools`), kept in `.karni/config.toml` in the project (committed) or
+  in `$XDG_CONFIG_HOME/karni/config.toml` with `--global`. The project wins.
   Machine-local state (e.g. "tip shown") lives in the self-ignoring
   `.karni/local/`.
-- `karni rules [--explain CODE | --procedure NAME | --check FILE... | --json]`
-  — Karni's conventions from `karni.agent.rules` (no Django needed), and
+- `karni rules [--explain CODE | --procedure NAME | --check FILE... | --json]`:
+  Karni's conventions from `karni.agent.rules` (no Django needed), and
   static single-file checks (exit 1 on violations).
-- `karni rules sync [--check] [--force]` — regenerate the thin agent adapters
+- `karni rules sync [--check] [--force]`: regenerate the thin agent adapters
   (AGENTS.md, CLAUDE.md, Cursor, Windsurf, Copilot, Cline, Aider, Junie) and
-  slash commands from `karni_cli/agent_adapters.toml`; `--check` is the CI
+  slash commands from `karni_cli/agent_adapters.toml`. `--check` is the CI
   staleness gate.
-- `karni mcp` — context, rules and check as MCP tools
+- `karni mcp`: context, rules and check as MCP tools
   (`pip install 'karni-cli[mcp]'`).
 - `karni upgrade [--to VERSION] [--from VERSION] [--dry-run] [--allow-dirty] [--list]`
   moves the project across Karni versions. It reads the karni installed in
   the project (`--from` overrides), takes every breaking change between that
   and `--to` from Karni's machine-readable changelog
   (`packages/karni/karni/changelog/*.toml`, bundled into karni-cli), and runs
-  their codemods in release order. Python codemods use libcst; TypeScript
-  codemods use a pinned jscodeshift through `npx` and are skipped, with the
-  reason, without Node.js. The codemods run on a scratch copy, and the result
+  their codemods in release order. Python codemods use libcst. TypeScript
+  codemods use a pinned jscodeshift through `npx`, and without Node.js they
+  are skipped with the reason. The codemods run on a scratch copy, and the result
   is written back all at once, or not at all if one fails. `--dry-run` prints
-  a unified diff and writes nothing. Writing needs a clean git tree;
+  a unified diff and writes nothing. Writing needs a clean git tree.
   `--allow-dirty` overrides that, and is also required outside git. The
   report lists what was applied (each file and its rewrite count), what could
   not be fixed automatically (the sites found, with each migration-note link)
@@ -110,7 +117,7 @@ See `docs/agents.md` for the agent surface in full.
 Artisan-style shortcuts. Each runner runs one project command through the
 project interpreter (see *Execution environment* below), streams its output
 and exits with its exit code. `--help` on each names the command it wraps.
-Extra arguments pass straight through; put `--` before any that clash with
+Extra arguments pass straight through. Put `--` before any that clash with
 karni's own options (`--docker`, `--service`, `--help`).
 
 | Command | Runs |
@@ -138,25 +145,25 @@ With the compose stack up, `worker` and `beat` already run as services, so
 ## Generators
 `karni make <type>` writes the project code a task needs, so neither a person
 nor an AI agent hand-creates a file a generator makes. `karni make --list`
-prints them all; every one is also a hidden Laravel-style alias
+prints them all. Each one is also available as a hidden Laravel-style alias,
 `karni make:<type>`. The full reference (every option, the field DSL) is
 [docs/cli.md](https://cbsshekhawat18-lab.github.io/karni/cli/), generated from this CLI.
 
 | Command | Writes |
 |---|---|
-| `karni make app NAME` | `NAME/{__init__,apps,models,viewsets}.py`, `migrations/`, `tests/`; wires `# karni:apps` |
-| `karni make model NAME [FIELD...]` | `class NAME(BaseModel)` in `<app>/models.py`; `--with viewset,page` / `-a` chains; `--migrate` |
+| `karni make app NAME` | `NAME/{__init__,apps,models,viewsets}.py`, `migrations/`, `tests/`, and wires `# karni:apps` |
+| `karni make model NAME [FIELD...]` | `class NAME(BaseModel)` in `<app>/models.py`, with `--with viewset,page` / `-a` chains and `--migrate` |
 | `karni make viewset MODEL` | `<Model>ViewSet` with its `access` (`--access authenticated\|public-read\|owned:<field>\|staff\|role:<name>`), `--search` |
 | `karni make serializer MODEL --reason ...` | `<app>/serializers.py` + `serializer_class` on the viewset |
 | `karni make migration [NAME]` | runs `manage.py makemigrations [--app] [--name] [--empty]` through the project interpreter |
 | `karni make task NAME` | `@shared_task` in `<app>/tasks.py` (`--retry N`) |
 | `karni make schedule NAME` | `every(...)`/`cron(...)` in `<app>/schedules.py` (`--every 15m` / `--cron "0 3 * * *"`, `--task`) |
 | `karni make event NAME` | a `Signal` in `<app>/events.py` |
-| `karni make listener NAME --on ...` | `<app>/listeners.py`: `Model.created\|updated\|deleted` or a custom event; `--queued` |
+| `karni make listener NAME --on ...` | `<app>/listeners.py`: `Model.created\|updated\|deleted` or a custom event, with `--queued` |
 | `karni make command NAME` | `<app>/management/commands/NAME.py` |
 | `karni make service NAME` | `<app>/services/NAME.py` (where HTTP clients are allowed) |
 | `karni make middleware NAME` | `<app>/middleware.py`, wired through `# karni:middleware` |
-| `karni make page NAME` | `frontend/src/pages/NAME.tsx` (≤ 50 lines; `--resource R --kind list\|detail\|form`), route in `frontend/src/routes.tsx` |
+| `karni make page NAME` | `frontend/src/pages/NAME.tsx` (≤ 50 lines, `--resource R --kind list\|detail\|form`), route in `frontend/src/routes.tsx` |
 | `karni make component NAME` | `frontend/src/components/NAME.tsx` claiming a role (`--role`) |
 | `karni make module NAME` | `modules/karni-NAME/` per docs/modules.md |
 
@@ -169,23 +176,24 @@ karni make listener notify_organizer --on Event.created --queued
 karni make schedule nightly-report --cron "0 3 * * *"
 ```
 
-Every generator: never overwrites without `--force`; `--dry-run` prints the
-files and diff and writes nothing; prints each created/modified file plus
-notes (the chosen `access`, the route, the next command); resolves the app
-from `--app` or the project's only local app; edits existing files only
-through marker comments or AST-located appends (an unfamiliar layout is an
-error naming the manual step); never imports Django. Generated Python is
-clean under ruff (lint and format) and `karni rules --check`, and generated
-pages parse and stay within 50 lines — `tests/test_make_gate.py` generates
-every type into a fresh scaffold and asserts it (plus `tsc` and the
-frontend's ESLint config when `KARNI_TEST_NODE_MODULES` points at an
-installed `frontend/node_modules`), then runs the generated backend for real
-(makemigrations, migrate, check, requests through the Django test client).
+Every generator follows the same rules. It never overwrites without
+`--force`, and `--dry-run` prints the files and diff and writes nothing. It
+prints each created/modified file plus notes (the chosen `access`, the route,
+the next command). It resolves the app from `--app` or the project's only
+local app. It edits existing files only through marker comments or
+AST-located appends, and an unfamiliar layout is an error naming the manual
+step. It never imports Django. Generated Python is clean under ruff (lint and
+format) and `karni rules --check`, and generated pages parse and stay within
+50 lines. `tests/test_make_gate.py` generates every type into a fresh scaffold
+and asserts this (plus `tsc` and the frontend's ESLint config when
+`KARNI_TEST_NODE_MODULES` points at an installed `frontend/node_modules`).
+Then it runs the generated backend for real (makemigrations, migrate, check,
+requests through the Django test client).
 
 Quote fields that end in `?` in zsh (`'venue:fk:Venue?'`) and choice values
 joined by `|`.
 
 ## Execution environment
 Commands that run the project resolve, in order: `--docker/--no-docker` flag →
-`<project>/.venv` → a running compose service (default `django`; change with
+`<project>/.venv` → a running compose service (default `django`, changed with
 `--service` or `KARNI_COMPOSE_SERVICE`) → an error naming both remedies.

{karni_cli-0.3.1 → karni_cli-0.4.0}/README.md

@@ -1,65 +1,72 @@
 # karni-cli
 
-The `karni` command. Orchestrates a Karni project's own `manage.py` via
-subprocess — the CLI itself never imports Django.
+The `karni` command. It runs a Karni project's own `manage.py` as a
+subprocess, so the CLI itself never imports Django.
 
 ## Commands
-- `karni new <name>` — scaffold a project from the bundled cookiecutter
-  template (monorepo checkouts use the live `templates/project`; override with
-  `KARNI_TEMPLATES`).
-- `karni add <module>` — add `karni-<module>` to `[project].dependencies` and
+- `karni new <name>`: scaffold a project from the bundled cookiecutter
+  template. Monorepo checkouts use the live `templates/project`, and
+  `KARNI_TEMPLATES` overrides it.
+- `karni add <module>`: add `karni-<module>` to `[project].dependencies` and
   wire `karni_<module>` into the `# karni:apps` block in config/settings.py.
-  Only that marker block is managed; any other layout gets a clear error and
+  Only that marker block is managed. Any other layout gets a clear error, and
   you edit settings manually.
   Once the module is installed it also records the module's
   `AGENTS.fragment.md` as `.karni/modules/<module>.md` and refreshes the agent
   adapters.
-- `karni types` — dump the OpenAPI schema (`manage.py spectacular`), generate
+- `karni types`: dump the OpenAPI schema (`manage.py spectacular`), generate
   `types.ts` (openapi-typescript, project-pinned binary preferred, else
   `npx openapi-typescript@^7`) and typed hooks (`hooks.ts`) over @karni/ui.
-- `karni context` — compact machine-readable inventory (< 200 tokens for a
-  typical project): APPS (from the `# karni:apps` block) and PAGES (from
-  `frontend/src/pages/`) read statically, MODELS/VIEWSETS from `manage.py karni_context`,
-  COMPONENTS/HOOKS from @karni/ui's build-generated `dist/manifest.json`
-  (omitted when absent — run `npm i @karni/ui` in `frontend/` on the host to
-  enable them; `--manifest PATH` overrides). Nothing is hand-maintained.
-- `karni context --with-history [PATH]` — the same inventory plus a
+- `karni ui detect`: map the frontend's design system (shadcn/ui, a Tailwind
+  theme, Material UI, Chakra UI or Mantine) onto @karni/ui's `--karni-*`
+  tokens in `karni-theme.css`, plus `karni-primitives.tsx` for shadcn/ui.
+  `--dry-run` previews, `--json` reports for agents, and edited files are kept
+  unless `--force`.
+- `karni context`: a compact machine-readable inventory (< 200 tokens for a
+  typical project). APPS (from the `# karni:apps` block) and PAGES (from
+  `frontend/src/pages/`) are read statically, MODELS/VIEWSETS come from `manage.py karni_context`,
+  and COMPONENTS/HOOKS from @karni/ui's build-generated `dist/manifest.json`.
+  Those two are omitted when the manifest is absent. Run `npm i @karni/ui` in
+  `frontend/` on the host to enable them, or override with `--manifest PATH`.
+  Nothing is hand-maintained.
+- `karni context --with-history [PATH]`: the same inventory plus a
   `HISTORY:` brief of what was already asked and decided about PATH (without
   PATH: the project's recorded decisions) from any history provider that
   detects a store, e.g. Gigai Chronicle's `.chronicle/`. Capped at ~300
   tokens (characters ÷ 4), cut at line boundaries with a last line naming the
   full-brief command. With no store the output is exactly `karni context`'s.
   See `docs/concepts/history-providers.md`.
-- `karni check [-q]` — Django system checks plus `karni.checks` entry-point hooks
+- `karni check [-q]`: Django system checks plus `karni.checks` entry-point hooks
   (the architecture-test extension surface). A clean run outside CI may end
-  with one tip on stderr, at most once per project; `-q` suppresses it.
-- `karni doctor [-q]` — human-readable environment report: project,
-  interpreter (`.venv` / compose service), Node/npm, the @karni/ui manifest,
-  adapter freshness, history providers. May end with the same one-time tip.
-- `karni config get|set|list [--global] KEY [VALUE]` — settings
-  (`suggest_tools`): `.karni/config.toml` in the project (committed) or
-  `$XDG_CONFIG_HOME/karni/config.toml` with `--global`; the project wins.
+  with one tip on stderr, at most once per project. `-q` suppresses it.
+- `karni doctor [-q]`: a human-readable environment report covering the
+  project, interpreter (`.venv` / compose service), Node/npm, the @karni/ui
+  manifest, adapter freshness and history providers. It may end with the same
+  one-time tip.
+- `karni config get|set|list [--global] KEY [VALUE]`: settings
+  (`suggest_tools`), kept in `.karni/config.toml` in the project (committed) or
+  in `$XDG_CONFIG_HOME/karni/config.toml` with `--global`. The project wins.
   Machine-local state (e.g. "tip shown") lives in the self-ignoring
   `.karni/local/`.
-- `karni rules [--explain CODE | --procedure NAME | --check FILE... | --json]`
-  — Karni's conventions from `karni.agent.rules` (no Django needed), and
+- `karni rules [--explain CODE | --procedure NAME | --check FILE... | --json]`:
+  Karni's conventions from `karni.agent.rules` (no Django needed), and
   static single-file checks (exit 1 on violations).
-- `karni rules sync [--check] [--force]` — regenerate the thin agent adapters
+- `karni rules sync [--check] [--force]`: regenerate the thin agent adapters
   (AGENTS.md, CLAUDE.md, Cursor, Windsurf, Copilot, Cline, Aider, Junie) and
-  slash commands from `karni_cli/agent_adapters.toml`; `--check` is the CI
+  slash commands from `karni_cli/agent_adapters.toml`. `--check` is the CI
   staleness gate.
-- `karni mcp` — context, rules and check as MCP tools
+- `karni mcp`: context, rules and check as MCP tools
   (`pip install 'karni-cli[mcp]'`).
 - `karni upgrade [--to VERSION] [--from VERSION] [--dry-run] [--allow-dirty] [--list]`
   moves the project across Karni versions. It reads the karni installed in
   the project (`--from` overrides), takes every breaking change between that
   and `--to` from Karni's machine-readable changelog
   (`packages/karni/karni/changelog/*.toml`, bundled into karni-cli), and runs
-  their codemods in release order. Python codemods use libcst; TypeScript
-  codemods use a pinned jscodeshift through `npx` and are skipped, with the
-  reason, without Node.js. The codemods run on a scratch copy, and the result
+  their codemods in release order. Python codemods use libcst. TypeScript
+  codemods use a pinned jscodeshift through `npx`, and without Node.js they
+  are skipped with the reason. The codemods run on a scratch copy, and the result
   is written back all at once, or not at all if one fails. `--dry-run` prints
-  a unified diff and writes nothing. Writing needs a clean git tree;
+  a unified diff and writes nothing. Writing needs a clean git tree.
   `--allow-dirty` overrides that, and is also required outside git. The
   report lists what was applied (each file and its rewrite count), what could
   not be fixed automatically (the sites found, with each migration-note link)
@@ -72,7 +79,7 @@ See `docs/agents.md` for the agent surface in full.
 Artisan-style shortcuts. Each runner runs one project command through the
 project interpreter (see *Execution environment* below), streams its output
 and exits with its exit code. `--help` on each names the command it wraps.
-Extra arguments pass straight through; put `--` before any that clash with
+Extra arguments pass straight through. Put `--` before any that clash with
 karni's own options (`--docker`, `--service`, `--help`).
 
 | Command | Runs |
@@ -100,25 +107,25 @@ With the compose stack up, `worker` and `beat` already run as services, so
 ## Generators
 `karni make <type>` writes the project code a task needs, so neither a person
 nor an AI agent hand-creates a file a generator makes. `karni make --list`
-prints them all; every one is also a hidden Laravel-style alias
+prints them all. Each one is also available as a hidden Laravel-style alias,
 `karni make:<type>`. The full reference (every option, the field DSL) is
 [docs/cli.md](https://cbsshekhawat18-lab.github.io/karni/cli/), generated from this CLI.
 
 | Command | Writes |
 |---|---|
-| `karni make app NAME` | `NAME/{__init__,apps,models,viewsets}.py`, `migrations/`, `tests/`; wires `# karni:apps` |
-| `karni make model NAME [FIELD...]` | `class NAME(BaseModel)` in `<app>/models.py`; `--with viewset,page` / `-a` chains; `--migrate` |
+| `karni make app NAME` | `NAME/{__init__,apps,models,viewsets}.py`, `migrations/`, `tests/`, and wires `# karni:apps` |
+| `karni make model NAME [FIELD...]` | `class NAME(BaseModel)` in `<app>/models.py`, with `--with viewset,page` / `-a` chains and `--migrate` |
 | `karni make viewset MODEL` | `<Model>ViewSet` with its `access` (`--access authenticated\|public-read\|owned:<field>\|staff\|role:<name>`), `--search` |
 | `karni make serializer MODEL --reason ...` | `<app>/serializers.py` + `serializer_class` on the viewset |
 | `karni make migration [NAME]` | runs `manage.py makemigrations [--app] [--name] [--empty]` through the project interpreter |
 | `karni make task NAME` | `@shared_task` in `<app>/tasks.py` (`--retry N`) |
 | `karni make schedule NAME` | `every(...)`/`cron(...)` in `<app>/schedules.py` (`--every 15m` / `--cron "0 3 * * *"`, `--task`) |
 | `karni make event NAME` | a `Signal` in `<app>/events.py` |
-| `karni make listener NAME --on ...` | `<app>/listeners.py`: `Model.created\|updated\|deleted` or a custom event; `--queued` |
+| `karni make listener NAME --on ...` | `<app>/listeners.py`: `Model.created\|updated\|deleted` or a custom event, with `--queued` |
 | `karni make command NAME` | `<app>/management/commands/NAME.py` |
 | `karni make service NAME` | `<app>/services/NAME.py` (where HTTP clients are allowed) |
 | `karni make middleware NAME` | `<app>/middleware.py`, wired through `# karni:middleware` |
-| `karni make page NAME` | `frontend/src/pages/NAME.tsx` (≤ 50 lines; `--resource R --kind list\|detail\|form`), route in `frontend/src/routes.tsx` |
+| `karni make page NAME` | `frontend/src/pages/NAME.tsx` (≤ 50 lines, `--resource R --kind list\|detail\|form`), route in `frontend/src/routes.tsx` |
 | `karni make component NAME` | `frontend/src/components/NAME.tsx` claiming a role (`--role`) |
 | `karni make module NAME` | `modules/karni-NAME/` per docs/modules.md |
 
@@ -131,23 +138,24 @@ karni make listener notify_organizer --on Event.created --queued
 karni make schedule nightly-report --cron "0 3 * * *"
 ```
 
-Every generator: never overwrites without `--force`; `--dry-run` prints the
-files and diff and writes nothing; prints each created/modified file plus
-notes (the chosen `access`, the route, the next command); resolves the app
-from `--app` or the project's only local app; edits existing files only
-through marker comments or AST-located appends (an unfamiliar layout is an
-error naming the manual step); never imports Django. Generated Python is
-clean under ruff (lint and format) and `karni rules --check`, and generated
-pages parse and stay within 50 lines — `tests/test_make_gate.py` generates
-every type into a fresh scaffold and asserts it (plus `tsc` and the
-frontend's ESLint config when `KARNI_TEST_NODE_MODULES` points at an
-installed `frontend/node_modules`), then runs the generated backend for real
-(makemigrations, migrate, check, requests through the Django test client).
+Every generator follows the same rules. It never overwrites without
+`--force`, and `--dry-run` prints the files and diff and writes nothing. It
+prints each created/modified file plus notes (the chosen `access`, the route,
+the next command). It resolves the app from `--app` or the project's only
+local app. It edits existing files only through marker comments or
+AST-located appends, and an unfamiliar layout is an error naming the manual
+step. It never imports Django. Generated Python is clean under ruff (lint and
+format) and `karni rules --check`, and generated pages parse and stay within
+50 lines. `tests/test_make_gate.py` generates every type into a fresh scaffold
+and asserts this (plus `tsc` and the frontend's ESLint config when
+`KARNI_TEST_NODE_MODULES` points at an installed `frontend/node_modules`).
+Then it runs the generated backend for real (makemigrations, migrate, check,
+requests through the Django test client).
 
 Quote fields that end in `?` in zsh (`'venue:fk:Venue?'`) and choice values
 joined by `|`.
 
 ## Execution environment
 Commands that run the project resolve, in order: `--docker/--no-docker` flag →
-`<project>/.venv` → a running compose service (default `django`; change with
+`<project>/.venv` → a running compose service (default `django`, changed with
 `--service` or `KARNI_COMPOSE_SERVICE`) → an error naming both remedies.

{karni_cli-0.3.1 → karni_cli-0.4.0}/hatch_build.py

@@ -11,7 +11,10 @@ to Karni's machine-readable changelog (packages/karni/karni/changelog ->
 karni_cli/_changelog), which `karni upgrade` reads: the CLI must know every
 change up to its own release, whatever karni the project has installed.
 Likewise Karni's error code registry (packages/karni/karni/errorcodes ->
-karni_cli/_errorcodes), which `karni explain` and error messages read.
+karni_cli/_errorcodes), which `karni explain` and error messages read, and
+@karni/ui's token stylesheet (packages/karni-ui/src/styles.css ->
+karni_cli/_ui/styles.css), whose defaults `karni ui detect` lists when a
+project has neither @karni/ui installed nor a monorepo checkout.
 """
 
 from __future__ import annotations
@@ -58,6 +61,15 @@ class TemplateBundleHook(BuildHookInterface):
         elif not bundled_links.is_file():
             raise RuntimeError("No karni/links.py to bundle into karni_cli/_errorcodes.")
 
+        styles = pkg_root.parent / "karni-ui" / "src" / "styles.css"
+        bundled_styles = pkg_root / "karni_cli" / "_ui" / "styles.css"
+        if styles.is_file():
+            bundled_styles.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(styles, bundled_styles)
+        elif not bundled_styles.is_file():
+            raise RuntimeError("No @karni/ui styles.css to bundle into karni_cli/_ui.")
+        build_data["artifacts"].append("karni_cli/_ui/")
+
     @staticmethod
     def _bundle_karni(
         pkg_root: Path, package: str, bundle: str, what: str, build_data: dict[str, Any]

{karni_cli-0.3.1 → karni_cli-0.4.0}/karni_cli/__init__.py

@@ -1,3 +1,3 @@
 """karni-cli — the ``karni`` command."""
 
-__version__ = "0.3.1"
+__version__ = "0.4.0"

{karni_cli-0.3.1 → karni_cli-0.4.0}/karni_cli/_agent/check.py

@@ -290,7 +290,7 @@ def _python(path: str, text: str) -> list[tuple[Finding, list[int]]]:
                         _finding(
                             "viewset-access",
                             node.lineno,
-                            f"{node.name} declares no `access` — every request is denied",
+                            f"{node.name} declares no `access`, so every request is denied",
                         ),
                         _class_lines(node),
                     )
@@ -301,7 +301,7 @@ def _python(path: str, text: str) -> list[tuple[Finding, list[int]]]:
                         _finding(
                             "redundant-serializer",
                             node.lineno,
-                            f"{node.name} is a Meta-only ModelSerializer — "
+                            f"{node.name} is a Meta-only ModelSerializer, and "
                             "BaseViewSet(model=X) already generates it",
                         ),
                         _class_lines(node),
@@ -329,7 +329,7 @@ def _python(path: str, text: str) -> list[tuple[Finding, list[int]]]:
                 _finding(
                     "access-override",
                     lineno,
-                    "filter_queryset_for_user overridden — express row rules in `access`",
+                    "filter_queryset_for_user overridden: express row rules in `access`",
                 ),
                 candidates,
             )
@@ -562,7 +562,7 @@ def _ts(path: str, text: str) -> list[Finding]:
                 report(
                     "karni/no-raw-elements",
                     number,
-                    f"raw <{element}> — compose {_REPLACEMENTS[element]} from @karni/ui",
+                    f"raw <{element}>: compose {_REPLACEMENTS[element]} from @karni/ui",
                 )
     if "pages" in parts[:-1]:
         physical = text.split("\n")
@@ -587,7 +587,7 @@ def _ts(path: str, text: str) -> list[Finding]:
             if _FETCH.search(bare):
                 report("karni/no-direct-http", number, "direct fetch() outside src/api/")
             if _AXIOS.search(code):
-                report("karni/no-direct-http", number, "axios import — Karni ships the HTTP layer")
+                report("karni/no-direct-http", number, "axios import: Karni ships the HTTP layer")
             for m in _NEW_TRANSPORT.finditer(bare):
                 report("karni/no-direct-http", number, f"new {m.group(1)}() outside src/api/")
     return findings
@@ -620,7 +620,7 @@ def check_source(path: str | Path, text: str) -> list[Finding]:
         except SyntaxError as exc:
             raise SourceParseError(
                 f"{path}:{exc.lineno}: cannot parse: {exc.msg}. karni check reads code "
-                "statically; fix the syntax error and run it again."
+                "statically. Fix the syntax error and run it again."
             ) from None
         findings = _python_optouts(text.splitlines(), found)
     elif suffix in TS_SUFFIXES:

{karni_cli-0.3.1 → karni_cli-0.4.0}/karni_cli/_agent/history.py

@@ -288,7 +288,7 @@ def _truncation_line(
     full_command = getattr(provider, "full_command", None)
     command = _safe(lambda: full_command(root, path)) if callable(full_command) else None
     if isinstance(command, str) and command.strip():
-        return f"… truncated at ~{max_tokens} tokens; full brief: {command.strip()}"
+        return f"… truncated at ~{max_tokens} tokens. Full brief: {command.strip()}"
     return f"… truncated at ~{max_tokens} tokens; {provider.name} holds the full brief"
 
 

{karni_cli-0.3.1 → karni_cli-0.4.0}/karni_cli/_agent/history_chronicle.py

@@ -221,7 +221,8 @@ def brief_from_pack(prompts: object, knowledge: object) -> str:
         for i, prompt in enumerate(shaped, start=1):
             text = prompt.get("text")
             quoted = '"' + " ".join(text.split()) + '"' if isinstance(text, str) else "(no text)"
-            lines.append(f"{i}. {_when(prompt.get('ts'))} {prompt.get('churn', '')} — {quoted}")
+            label = f"{_when(prompt.get('ts'))} {prompt.get('churn', '')}".strip()
+            lines.append(f"{i}. {label}: {quoted}" if label else f"{i}. {quoted}")
     return "\n".join(_SPACES.sub(" ", line) for line in lines)
 
 

{karni_cli-0.3.1 → karni_cli-0.4.0}/karni_cli/_agent/overrides.py

@@ -64,7 +64,7 @@ def _literal(node: ast.expr, name: str, path: Path) -> Any:
         return ast.literal_eval(node)
     except ValueError:
         raise OverrideError(
-            f"{path}:{node.lineno}: {name} must be a literal (strings, lists, dicts) — "
+            f"{path}:{node.lineno}: {name} must be a literal (strings, lists, dicts). "
             "karni.rules.py is read statically and never executed."
         ) from None