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

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

@@ -19,6 +19,8 @@ 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/_settings/
+packages/karni-cli/karni_cli/_catalog/
 packages/karni-cli/karni_cli/_ui/
 
 # Node
@@ -32,8 +34,11 @@ storybook-static/
 !.env.example
 .DS_Store
 .idea/
-.claude/scheduled_tasks.lock
-.claude/settings.local.json
 
 # MkDocs build output
 site/
+.github/ci/prod_e2e/test-results/
+
+# Contributors' own agent working files stay on their machines
+/CLAUDE.md
+/.claude/

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

@@ -1,7 +1,7 @@
 Metadata-Version: 2.5
 Name: karni-cli
-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.
+Version: 0.5.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 every coding agent. 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
@@ -10,7 +10,7 @@ Project-URL: Changelog, https://github.com/cbsshekhawat18-lab/karni/tree/main/do
 Author-email: Chandrabhan Shekhawat <cbsshekhawat18@gmail.com>
 License-Expression: Apache-2.0
 License-File: LICENSE
-Keywords: ai-agents,claude-code,cli,code-generation,cookiecutter,copilot,cursor,django,mcp,project-template,react,scaffolding
+Keywords: ai-agents,cli,code-generation,cookiecutter,django,mcp,project-template,react,scaffolding
 Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Console
 Classifier: Framework :: Django
@@ -29,6 +29,7 @@ Requires-Python: >=3.12
 Requires-Dist: cookiecutter>=2.5
 Requires-Dist: libcst>=1.4
 Requires-Dist: packaging>=24.0
+Requires-Dist: pydantic>=2
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: tomlkit>=0.12
 Requires-Dist: typer>=0.12
@@ -38,8 +39,45 @@ Description-Content-Type: text/markdown
 
 # karni-cli
 
-The `karni` command. It runs a Karni project's own `manage.py` as a
-subprocess, so the CLI itself never imports Django.
+The karni command: scaffold, generate, run and upgrade Karni projects.
+
+[![PyPI](https://img.shields.io/pypi/v/karni-cli)](https://pypi.org/project/karni-cli/) [![Python versions](https://img.shields.io/pypi/pyversions/karni-cli)](https://pypi.org/project/karni-cli/) [![License: Apache-2.0](https://img.shields.io/badge/license-Apache--2.0-blue)](https://github.com/cbsshekhawat18-lab/karni/blob/main/LICENSE) [![Docs](https://img.shields.io/badge/docs-online-FB5D08)](https://cbsshekhawat18-lab.github.io/karni/cli/)
+
+It runs a project's own `manage.py` as a subprocess, so the CLI itself never imports Django. Karni's Python core is [`karni`](https://pypi.org/project/karni/) and its React side [`@karni/ui`](https://www.npmjs.com/package/@karni/ui).
+
+## Install
+
+```sh
+pip install karni-cli
+```
+
+## A minimal example
+
+The shop recipe, built on SQLite with no Docker:
+
+```sh
+python3 -m venv .venv && . .venv/bin/activate
+pip install karni karni-cli karni-payments pytest pytest-django
+karni new "Corner Shop" --recipe shop && cd corner_shop
+printf 'DATABASE_URL=sqlite:///data/db.sqlite3\nKARNI_CACHE=locmem\n' > .env
+karni build
+karni serve --local
+```
+
+`karni build` runs the migrations, seeds demo data, generates the TypeScript types, and runs the tests and `karni check`. The [quickstart](https://cbsshekhawat18-lab.github.io/karni/quickstart/) does the same on PostgreSQL.
+
+## Main features
+
+- **Start a project.** `karni new` scaffolds a site, an app or both, blank or from one of six [recipes](https://cbsshekhawat18-lab.github.io/karni/recipes/).
+- **Build from a spec.** `karni spec validate`, `karni plan` and `karni build` turn `karni.yaml` into code ([the app spec](https://cbsshekhawat18-lab.github.io/karni/app-spec/)).
+- **Generate.** `karni make app`, `model`, `page`, `schedule`, `task`, `site` and `form` write the files a project owns.
+- **Modules.** `karni add` and `karni remove` wire a module in and out, and `karni modules` lists the catalog.
+- **Run and check.** `karni serve`, `seed`, `migrate`, `test`, `types` and `check`, the last one failing the build when code rebuilds what Karni ships.
+- **For coding agents.** `karni context`, `karni rules`, the procedures in AGENTS.md and `karni mcp`, the MCP server ([Karni for coding agents](https://cbsshekhawat18-lab.github.io/karni/agents/)).
+- **Debugging.** `karni why`, `karni explain`, `karni trace`, `karni replay` and `karni queries` ([debugging](https://cbsshekhawat18-lab.github.io/karni/debugging/why/)).
+- **Upgrades.** `karni upgrade` applies each release's codemods and lists what it could not change.
+
+Every command and option is in [the karni command](https://cbsshekhawat18-lab.github.io/karni/cli/). A short list follows.
 
 ## Commands
 - `karni new <name>`: scaffold a project from the bundled cookiecutter
@@ -89,10 +127,9 @@ subprocess, so the CLI itself never imports Django.
 - `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
-  (AGENTS.md, CLAUDE.md, Cursor, Windsurf, Copilot, Cline, Aider, Junie) and
-  slash commands from `karni_cli/agent_adapters.toml`. `--check` is the CI
-  staleness gate.
+- `karni rules sync [--check] [--force]`: regenerate AGENTS.md, the agent
+  instructions with the procedures for routine tasks, from
+  `karni_cli/agent_adapters.toml`. `--check` is the CI staleness gate.
 - `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]`
@@ -197,3 +234,12 @@ joined by `|`.
 Commands that run the project resolve, in order: `--docker/--no-docker` flag →
 `<project>/.venv` → a running compose service (default `django`, changed with
 `--service` or `KARNI_COMPOSE_SERVICE`) → an error naming both remedies.
+
+## Links
+
+- The karni command: <https://cbsshekhawat18-lab.github.io/karni/cli/>
+- Quickstart: <https://cbsshekhawat18-lab.github.io/karni/quickstart/>
+- Karni, the framework this package is part of: <https://github.com/cbsshekhawat18-lab/karni>
+- Changelog: <https://github.com/cbsshekhawat18-lab/karni/blob/main/CHANGELOG.md>
+- Issues: <https://github.com/cbsshekhawat18-lab/karni/issues>
+- License: Apache-2.0. karni-cli is released with every other Karni package, at one version.

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

@@ -1,7 +1,44 @@
 # karni-cli
 
-The `karni` command. It runs a Karni project's own `manage.py` as a
-subprocess, so the CLI itself never imports Django.
+The karni command: scaffold, generate, run and upgrade Karni projects.
+
+[![PyPI](https://img.shields.io/pypi/v/karni-cli)](https://pypi.org/project/karni-cli/) [![Python versions](https://img.shields.io/pypi/pyversions/karni-cli)](https://pypi.org/project/karni-cli/) [![License: Apache-2.0](https://img.shields.io/badge/license-Apache--2.0-blue)](https://github.com/cbsshekhawat18-lab/karni/blob/main/LICENSE) [![Docs](https://img.shields.io/badge/docs-online-FB5D08)](https://cbsshekhawat18-lab.github.io/karni/cli/)
+
+It runs a project's own `manage.py` as a subprocess, so the CLI itself never imports Django. Karni's Python core is [`karni`](https://pypi.org/project/karni/) and its React side [`@karni/ui`](https://www.npmjs.com/package/@karni/ui).
+
+## Install
+
+```sh
+pip install karni-cli
+```
+
+## A minimal example
+
+The shop recipe, built on SQLite with no Docker:
+
+```sh
+python3 -m venv .venv && . .venv/bin/activate
+pip install karni karni-cli karni-payments pytest pytest-django
+karni new "Corner Shop" --recipe shop && cd corner_shop
+printf 'DATABASE_URL=sqlite:///data/db.sqlite3\nKARNI_CACHE=locmem\n' > .env
+karni build
+karni serve --local
+```
+
+`karni build` runs the migrations, seeds demo data, generates the TypeScript types, and runs the tests and `karni check`. The [quickstart](https://cbsshekhawat18-lab.github.io/karni/quickstart/) does the same on PostgreSQL.
+
+## Main features
+
+- **Start a project.** `karni new` scaffolds a site, an app or both, blank or from one of six [recipes](https://cbsshekhawat18-lab.github.io/karni/recipes/).
+- **Build from a spec.** `karni spec validate`, `karni plan` and `karni build` turn `karni.yaml` into code ([the app spec](https://cbsshekhawat18-lab.github.io/karni/app-spec/)).
+- **Generate.** `karni make app`, `model`, `page`, `schedule`, `task`, `site` and `form` write the files a project owns.
+- **Modules.** `karni add` and `karni remove` wire a module in and out, and `karni modules` lists the catalog.
+- **Run and check.** `karni serve`, `seed`, `migrate`, `test`, `types` and `check`, the last one failing the build when code rebuilds what Karni ships.
+- **For coding agents.** `karni context`, `karni rules`, the procedures in AGENTS.md and `karni mcp`, the MCP server ([Karni for coding agents](https://cbsshekhawat18-lab.github.io/karni/agents/)).
+- **Debugging.** `karni why`, `karni explain`, `karni trace`, `karni replay` and `karni queries` ([debugging](https://cbsshekhawat18-lab.github.io/karni/debugging/why/)).
+- **Upgrades.** `karni upgrade` applies each release's codemods and lists what it could not change.
+
+Every command and option is in [the karni command](https://cbsshekhawat18-lab.github.io/karni/cli/). A short list follows.
 
 ## Commands
 - `karni new <name>`: scaffold a project from the bundled cookiecutter
@@ -51,10 +88,9 @@ subprocess, so the CLI itself never imports Django.
 - `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
-  (AGENTS.md, CLAUDE.md, Cursor, Windsurf, Copilot, Cline, Aider, Junie) and
-  slash commands from `karni_cli/agent_adapters.toml`. `--check` is the CI
-  staleness gate.
+- `karni rules sync [--check] [--force]`: regenerate AGENTS.md, the agent
+  instructions with the procedures for routine tasks, from
+  `karni_cli/agent_adapters.toml`. `--check` is the CI staleness gate.
 - `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]`
@@ -159,3 +195,12 @@ joined by `|`.
 Commands that run the project resolve, in order: `--docker/--no-docker` flag →
 `<project>/.venv` → a running compose service (default `django`, changed with
 `--service` or `KARNI_COMPOSE_SERVICE`) → an error naming both remedies.
+
+## Links
+
+- The karni command: <https://cbsshekhawat18-lab.github.io/karni/cli/>
+- Quickstart: <https://cbsshekhawat18-lab.github.io/karni/quickstart/>
+- Karni, the framework this package is part of: <https://github.com/cbsshekhawat18-lab/karni>
+- Changelog: <https://github.com/cbsshekhawat18-lab/karni/blob/main/CHANGELOG.md>
+- Issues: <https://github.com/cbsshekhawat18-lab/karni/issues>
+- License: Apache-2.0. karni-cli is released with every other Karni package, at one version.

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

@@ -11,10 +11,15 @@ 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, and
+karni_cli/_errorcodes), which `karni explain` and error messages read, the
+settings reference (packages/karni/karni/conf/reference.py and the base.py it
+reads -> karni_cli/_settings), which `karni explain <SETTING>` reads, 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.
+project has neither @karni/ui installed nor a monorepo checkout. And the
+module catalog (packages/karni/karni/catalog -> karni_cli/_catalog, with a
+copy of each module's karni.module.toml under _catalog/modules/), so
+`karni modules list` shows the modules a project has not installed.
 """
 
 from __future__ import annotations
@@ -52,6 +57,15 @@ class TemplateBundleHook(BuildHookInterface):
         self._bundle_karni(pkg_root, "agent", "_agent", "agent rules", build_data)
         self._bundle_karni(pkg_root, "changelog", "_changelog", "changelog", build_data)
         self._bundle_karni(pkg_root, "errorcodes", "_errorcodes", "error codes", build_data)
+        self._bundle_karni(pkg_root, "catalog", "_catalog", "module catalog", build_data)
+        manifests = sorted(pkg_root.parent.parent.glob("modules/*/karni_*/karni.module.toml"))
+        bundled_modules = pkg_root / "karni_cli" / "_catalog" / "modules"
+        if manifests:
+            bundled_modules.mkdir(parents=True, exist_ok=True)
+            for manifest in manifests:
+                shutil.copy2(manifest, bundled_modules / f"{manifest.parent.parent.name}.toml")
+        elif not bundled_modules.is_dir():
+            raise RuntimeError("No module manifests to bundle into karni_cli/_catalog/modules.")
         # karni.links (every published URL, stdlib only) rides inside the
         # errorcodes bundle: the registry loads it by path when karni is absent.
         links = pkg_root.parent / "karni" / "karni" / "links.py"
@@ -61,6 +75,17 @@ class TemplateBundleHook(BuildHookInterface):
         elif not bundled_links.is_file():
             raise RuntimeError("No karni/links.py to bundle into karni_cli/_errorcodes.")
 
+        # The settings reference (stdlib only) and the file it reads: `karni explain <SETTING>`.
+        settings_bundle = pkg_root / "karni_cli" / "_settings"
+        conf = pkg_root.parent / "karni" / "karni" / "conf"
+        if (conf / "reference.py").is_file():
+            settings_bundle.mkdir(parents=True, exist_ok=True)
+            for name in ("reference.py", "base.py"):
+                shutil.copy2(conf / name, settings_bundle / name)
+        elif not (settings_bundle / "reference.py").is_file():
+            raise RuntimeError("No karni/conf/reference.py to bundle into karni_cli/_settings.")
+        build_data["artifacts"].append("karni_cli/_settings/")
+
         styles = pkg_root.parent / "karni-ui" / "src" / "styles.css"
         bundled_styles = pkg_root / "karni_cli" / "_ui" / "styles.css"
         if styles.is_file():

karni_cli-0.5.0/karni_cli/__init__.py

@@ -0,0 +1,8 @@
+"""karni-cli — the ``karni`` command."""
+
+from importlib import metadata as _metadata
+
+try:
+    __version__ = _metadata.version("karni-cli")  # [project] version in pyproject.toml
+except _metadata.PackageNotFoundError:  # a source tree on sys.path, never installed
+    __version__ = "0+unknown"

{karni_cli-0.4.0 → karni_cli-0.5.0}/karni_cli/_agent/__init__.py

@@ -16,7 +16,7 @@ from typing import Any
 from .check import check_file, check_source, supported
 from .history import active_conditions
 from .overrides import OVERRIDE_FILE, OverrideError, read_overrides, resolve_rules
-from .rules import CATEGORIES, PROCEDURES, RULES, Procedure, Rule
+from .rules import CATEGORIES, PROCEDURES, RULES, TOPICS, Procedure, Rule, Topic
 
 #: Bumped when the shape of :func:`dump` changes incompatibly.
 SCHEMA_VERSION = 1
@@ -27,9 +27,11 @@ __all__ = [
     "PROCEDURES",
     "RULES",
     "SCHEMA_VERSION",
+    "TOPICS",
     "OverrideError",
     "Procedure",
     "Rule",
+    "Topic",
     "check_file",
     "check_paths",
     "check_source",
@@ -64,6 +66,7 @@ def dump(root: str | Path | None = None) -> dict[str, Any]:
         "categories": [c for c in categories if any(r.category == c for r in rules)],
         "rules": [rule.to_dict() for rule in rules],
         "procedures": [procedure.to_dict() for procedure in PROCEDURES],
+        "topics": [topic.to_dict() for topic in TOPICS],
         "adapters": overrides.adapters,
         "overrides_file": str(overrides.path) if overrides.path else None,
         "conditions": sorted(conditions),

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

@@ -31,9 +31,17 @@ from .rules import ENFORCEMENT_CODES, rules_by_code
 SQL_ALLOWED: tuple[str, ...] = ("*/sql/*", "*/migrations/*")
 HTTP_ALLOWED: tuple[str, ...] = ("*/services/*", "*/providers/*", "*/tests/*", "conftest.py")
 HTTP_BANNED: frozenset[str] = frozenset({"requests", "httpx", "urllib.request"})
-#: Any of these as a base satisfies model-base (BaseModel or its mixins).
+#: Any of these as a base satisfies model-base (BaseModel, BigIntBaseModel or their mixins).
 KARNI_MODEL_BASES: frozenset[str] = frozenset(
-    {"BaseModel", "UUIDModel", "TimestampedModel", "SoftDeleteModel", "AuditedModel"}
+    {
+        "BaseModel",
+        "BigIntBaseModel",
+        "UUIDModel",
+        "IntegerKeyModel",
+        "TimestampedModel",
+        "SoftDeleteModel",
+        "AuditedModel",
+    }
 )
 _DRF_VIEWSETS = frozenset({"GenericViewSet", "ModelViewSet", "ReadOnlyModelViewSet"})
 
@@ -42,6 +50,7 @@ TS_SUFFIXES = frozenset({".ts", ".tsx", ".js", ".jsx", ".mts", ".cts", ".mjs", "
 JSX_SUFFIXES = frozenset({".tsx", ".jsx"})
 PAGE_MAX_LINES = 50
 
+_PY_ALLOW_START = re.compile(r"#\s*karni:\s*allow\(")
 _PY_ALLOW = re.compile(r"#\s*karni:\s*allow\(([^)]*)\)\s*(?::\s*(.*))?$")
 # ESLint only honours a directive that opens the comment (`// eslint-disable...`
 # or `/* eslint-disable... */`); prose that merely mentions it is not one.
@@ -125,6 +134,32 @@ def _is_abstract(cls: ast.ClassDef) -> bool:
     return False
 
 
+def _nested_constant(cls: ast.ClassDef, nested: str, name: str) -> object:
+    """The constant ``name = <value>`` in ``cls``'s nested class ``nested``, else ``None``."""
+    for stmt in cls.body:
+        if isinstance(stmt, ast.ClassDef) and stmt.name == nested:
+            for item in stmt.body:
+                if (
+                    isinstance(item, ast.Assign)
+                    and any(isinstance(t, ast.Name) and t.id == name for t in item.targets)
+                    and isinstance(item.value, ast.Constant)
+                ):
+                    return item.value.value
+    return None
+
+
+def _is_external(cls: ast.ClassDef) -> bool:
+    """An external table or view (``karni.db``, experimental): model-base accepts it.
+
+    Both declarations are needed: ``class Karni: external = True`` and
+    ``class Meta: managed = False``.
+    """
+    return (
+        _nested_constant(cls, "Karni", "external") is True
+        and _nested_constant(cls, "Meta", "managed") is False
+    )
+
+
 def _class_lines(cls: ast.ClassDef) -> list[int]:
     first = min([cls.lineno, *(d.lineno for d in cls.decorator_list)])
     return sorted({cls.lineno, cls.lineno - 1, first, first - 1})
@@ -255,7 +290,12 @@ def _python(path: str, text: str) -> list[tuple[Finding, list[int]]]:
         if isinstance(node, ast.ClassDef):
             bases = {_dotted(b) for b in node.bases}
             short = {b.rsplit(".", 1)[-1] for b in bases}
-            if bases & model_names and not short & KARNI_MODEL_BASES and not _is_abstract(node):
+            if (
+                bases & model_names
+                and not short & KARNI_MODEL_BASES
+                and not _is_abstract(node)
+                and not _is_external(node)
+            ):
                 found.append(
                     (
                         _finding(
@@ -387,26 +427,31 @@ def http_client_imports(tree: ast.AST) -> list[tuple[int, str]]:
 
 
 def _python_optouts(lines: list[str], found: list[tuple[Finding, list[int]]]) -> list[Finding]:
-    markers: dict[int, tuple[set[str], str]] = {}
+    markers: dict[int, list[tuple[set[str], str]]] = {}
     for i, text in enumerate(lines, start=1):
-        m = _PY_ALLOW.search(text)
-        if m:
-            rules = {r.strip() for r in m.group(1).split(",") if r.strip()}
-            markers[i] = (rules, (m.group(2) or "").strip())
+        # A line may carry several markers, each reason running to the next one.
+        starts = [m.start() for m in _PY_ALLOW_START.finditer(text)]
+        for begin, end in zip(starts, [*starts[1:], len(text)][: len(starts)], strict=True):
+            m = _PY_ALLOW.match(text[begin:end].rstrip())
+            if m:
+                rules = {r.strip() for r in m.group(1).split(",") if r.strip()}
+                markers.setdefault(i, []).append((rules, (m.group(2) or "").strip()))
     result: list[Finding] = []
-    for i, (rules, reason) in sorted(markers.items()):
-        if not reason:
-            result.append(
-                _finding(
-                    "opt-out-reason",
-                    i,
-                    f"karni: allow({', '.join(sorted(rules))}) requires a non-empty reason",
+    for i, entries in sorted(markers.items()):
+        for rules, reason in entries:
+            if not reason:
+                result.append(
+                    _finding(
+                        "opt-out-reason",
+                        i,
+                        f"karni: allow({', '.join(sorted(rules))}) requires a non-empty reason",
+                    )
                 )
-            )
     for finding, candidates in found:
         allowed = any(
-            finding.rule_id in markers.get(line, (set(), ""))[0] and markers[line][1]
+            finding.rule_id in rules and reason
             for line in candidates
+            for rules, reason in markers.get(line, [])
         )
         if not allowed:
             result.append(finding)
@@ -415,7 +460,7 @@ def _python_optouts(lines: list[str], found: list[tuple[Finding, list[int]]]) ->
 
 # TypeScript / JavaScript
 
-_RAW_ELEMENT = re.compile(r"<(table|form|input|select|textarea)(?=[\s/>])")
+_RAW_ELEMENT = re.compile(r"<(table|form|input|select|textarea|details)(?=[\s/>])")
 _DEEP_IMPORT = re.compile(
     r"""(?:from\s+|import\s*\(\s*|require\s*\(\s*|import\s+)["']@karni/ui/(?:dist|src)(?:/[^"']*)?["']"""
 )
@@ -426,7 +471,8 @@ _NEW_TRANSPORT = re.compile(
     r"(?<![\w$.])new\s+(?:(?:window|globalThis|self)\.)?(XMLHttpRequest|WebSocket)\b"
 )
 _REPLACEMENTS = {
-    "table": "ResourceTable",
+    "table": "ResourceTable (a resource), DataTable (computed rows) or ComparisonTable",
+    "details": "Accordion",
     "form": "ResourceForm",
     "input": "Input (or ResourceForm)",
     "select": "Select / ResourceSelect",

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

@@ -14,7 +14,7 @@ Schema (every name optional)::
     ]
     OVERRIDE = {"K202": {"summary": "Page files stay at 80 lines or fewer."}}
     DISABLE = ["K304"]
-    ADAPTERS = {"disable": ["copilot"], "paths": {"windsurf": ".devin/rules/karni.md"}}
+    ADAPTERS = {"disable": [...], "paths": {"agents-md": "AGENTS.md"}}  # ids: agent_adapters.toml
 
 ``ADD += [...]`` and ``DISABLE += [...]`` are accepted (the upgrade codemod
 appends that way). Anything else at top level is an error that names the line.