defsort 0.1.0__tar.gz

defsort-0.1.0/.gitignore

@@ -0,0 +1,46 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+dist/
+.eggs/
+*.egg-info/
+*.egg
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage*
+.pytest_cache/
+.cache/
+
+# Type checker / linter caches
+.pyright/
+.mypy_cache/
+.ruff_cache/
+pyrightconfig.json
+
+# Editors
+.vscode/
+.idea/
+
+# OS
+.DS_Store
+Thumbs.db

defsort-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 the defsort authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

defsort-0.1.0/PKG-INFO

@@ -0,0 +1,150 @@
+Metadata-Version: 2.5
+Name: defsort
+Version: 0.1.0
+Summary: Sort Python definitions by dependency or alphabetically
+Project-URL: Documentation, https://github.com/dactylo/defsort/tree/main/docs
+Project-URL: Homepage, https://github.com/dactylo/defsort
+Project-URL: Issues, https://github.com/dactylo/defsort/issues
+Project-URL: Repository, https://github.com/dactylo/defsort
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ast,definitions,dependency,formatter,sort
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Typing :: Typed
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+
+# defsort
+
+[![CI](https://github.com/dactylo/defsort/actions/workflows/ci.yml/badge.svg)](https://github.com/dactylo/defsort/actions/workflows/ci.yml)
+
+Defsort applies a configurable ordering policy to Python functions, classes, and methods. It makes
+definition order deterministic, so placement follows a project convention rather than accumulating
+from successive edits.
+
+Run `defsort` to see how much would change across your project:
+
+![defsort summary of six Python files, with 15 of 26 definitions and methods moving](images/defsort-summary.png)
+
+Then use `defsort --preview` to see where definitions move. Colors track definitions between the
+Current and Proposed columns. For example:
+
+![defsort preview showing function movement in catalog.py and method movement in delivery.py](images/defsort-preview.png)
+
+Use the CLI to preview and apply changes, an agent hook to sort before commits, or the Python
+library to integrate sorting into your own tools.
+
+## Installation
+
+defsort requires CPython 3.13 or later. Install the current checkout from the repository root with
+[uv](https://docs.astral.sh/uv/):
+
+```bash
+uv tool install .
+```
+
+To update an existing installation after pulling changes:
+
+```bash
+uv tool install --reinstall .
+```
+
+Git 2.42 or newer is required for agent hooks, incremental mode, and a configured reorder guard.
+Ordinary CLI sorting and the library do not require Git. See
+[platform compatibility](docs/platform.md) for runtime requirements and file-handling details.
+
+## Quick start
+
+Start with a summary, preview movement, inspect the diff, then apply the changes:
+
+```bash
+defsort
+defsort --preview
+defsort --diff
+defsort --write
+```
+
+The first three commands leave files unchanged. They exit 1 when changes or skipped files need
+attention; exit 2 indicates an error. A successful write exits 0 unless files were skipped.
+
+Choose dependency or alphabetical ordering, with separate policies for top-level definitions and
+class methods. Automatic sorting trades control over individual placement for consistency.
+Dependency changes can produce large reorders; alphabetical order can separate related code. Use
+comment banners to preserve sections. See
+[ordering policies](docs/design.md#choose-an-ordering-policy) for the choices and tradeoffs.
+
+The defaults use dependency ordering, alphabetical ties, and lifecycle methods first. No
+configuration is required. To keep class methods in their authored order while sorting top-level
+definitions, add:
+
+```toml
+[tool.defsort]
+method-order = "none"
+```
+
+Defsort checks for changes that could break definition-time references and preserves decorators,
+comments, and source layout. Its checks are bounded: classes whose behavior depends on method order
+should use `method-order = "none"`. Read the [safety model](docs/design.md#safety-model) before
+adopting it in order-sensitive code.
+
+For an existing codebase, the [incremental guide](docs/incremental.md) explains how to establish
+sorted baselines file by file and limit later reordering.
+
+## Integrations
+
+- **Coding agents:** the recommended PreToolUse hook sorts staged Python content before supported
+  commits and preserves partial staging. Follow the [hook setup guide](docs/hook.md#configuration)
+  for Claude Code, Codex, or Antigravity. Choose either plugin installation or manual registration.
+- **Multiple formatting hooks:** use the
+  [composition guide](docs/hook.md#composing-with-other-hooks) to run modifying hooks in order. It
+  includes the current Antigravity limitation.
+- **pre-commit:** use a local registration with an installed CLI as described in the
+  [pre-commit guide](docs/hook.md#pre-commit).
+
+## Library API
+
+```python
+import defsort
+
+source = 'def zebra(): pass\n\ndef alpha(): pass\n'
+result = defsort.check(source)
+if result.status == 'changed':
+    source = defsort.sort(source)
+```
+
+Use `check()` to inspect skipped or invalid source before deciding what to do. The
+[library reference](docs/library.md) describes configuration, results, and the public adapter API.
+
+## Documentation
+
+| If you want to...                                   | Read                                       |
+| --------------------------------------------------- | ------------------------------------------ |
+| Choose an ordering policy and understand its limits | [Concepts and safety](docs/design.md)      |
+| Preview, apply, or automate a sort                  | [CLI reference](docs/cli.md)               |
+| Configure agent hooks or pre-commit                 | [Hook guide](docs/hook.md)                 |
+| Control reordering during adoption                  | [Incremental mode](docs/incremental.md)    |
+| Call defsort from Python                            | [Library reference](docs/library.md)       |
+| Check runtime, encoding, or path behavior           | [Platform compatibility](docs/platform.md) |
+
+## Development
+
+See the [development guide](docs/development.md) for pinned CI dependencies and lock updates.
+
+Provide the tools in `[dependency-groups].dev` through your environment or package manager.
+`make install` and `make reinstall` install only the CLI through uv.
+
+```bash
+make quality # read-only quality checks
+make check   # quality checks and one full test run
+make format  # apply repository formatters
+```
+
+To contribute an agent integration, see
+[adding a bundled agent](docs/hook.md#adding-a-bundled-agent).
+
+## License
+
+defsort is distributed under the [MIT License](LICENSE).

defsort-0.1.0/README.md

@@ -0,0 +1,131 @@
+# defsort
+
+[![CI](https://github.com/dactylo/defsort/actions/workflows/ci.yml/badge.svg)](https://github.com/dactylo/defsort/actions/workflows/ci.yml)
+
+Defsort applies a configurable ordering policy to Python functions, classes, and methods. It makes
+definition order deterministic, so placement follows a project convention rather than accumulating
+from successive edits.
+
+Run `defsort` to see how much would change across your project:
+
+![defsort summary of six Python files, with 15 of 26 definitions and methods moving](images/defsort-summary.png)
+
+Then use `defsort --preview` to see where definitions move. Colors track definitions between the
+Current and Proposed columns. For example:
+
+![defsort preview showing function movement in catalog.py and method movement in delivery.py](images/defsort-preview.png)
+
+Use the CLI to preview and apply changes, an agent hook to sort before commits, or the Python
+library to integrate sorting into your own tools.
+
+## Installation
+
+defsort requires CPython 3.13 or later. Install the current checkout from the repository root with
+[uv](https://docs.astral.sh/uv/):
+
+```bash
+uv tool install .
+```
+
+To update an existing installation after pulling changes:
+
+```bash
+uv tool install --reinstall .
+```
+
+Git 2.42 or newer is required for agent hooks, incremental mode, and a configured reorder guard.
+Ordinary CLI sorting and the library do not require Git. See
+[platform compatibility](docs/platform.md) for runtime requirements and file-handling details.
+
+## Quick start
+
+Start with a summary, preview movement, inspect the diff, then apply the changes:
+
+```bash
+defsort
+defsort --preview
+defsort --diff
+defsort --write
+```
+
+The first three commands leave files unchanged. They exit 1 when changes or skipped files need
+attention; exit 2 indicates an error. A successful write exits 0 unless files were skipped.
+
+Choose dependency or alphabetical ordering, with separate policies for top-level definitions and
+class methods. Automatic sorting trades control over individual placement for consistency.
+Dependency changes can produce large reorders; alphabetical order can separate related code. Use
+comment banners to preserve sections. See
+[ordering policies](docs/design.md#choose-an-ordering-policy) for the choices and tradeoffs.
+
+The defaults use dependency ordering, alphabetical ties, and lifecycle methods first. No
+configuration is required. To keep class methods in their authored order while sorting top-level
+definitions, add:
+
+```toml
+[tool.defsort]
+method-order = "none"
+```
+
+Defsort checks for changes that could break definition-time references and preserves decorators,
+comments, and source layout. Its checks are bounded: classes whose behavior depends on method order
+should use `method-order = "none"`. Read the [safety model](docs/design.md#safety-model) before
+adopting it in order-sensitive code.
+
+For an existing codebase, the [incremental guide](docs/incremental.md) explains how to establish
+sorted baselines file by file and limit later reordering.
+
+## Integrations
+
+- **Coding agents:** the recommended PreToolUse hook sorts staged Python content before supported
+  commits and preserves partial staging. Follow the [hook setup guide](docs/hook.md#configuration)
+  for Claude Code, Codex, or Antigravity. Choose either plugin installation or manual registration.
+- **Multiple formatting hooks:** use the
+  [composition guide](docs/hook.md#composing-with-other-hooks) to run modifying hooks in order. It
+  includes the current Antigravity limitation.
+- **pre-commit:** use a local registration with an installed CLI as described in the
+  [pre-commit guide](docs/hook.md#pre-commit).
+
+## Library API
+
+```python
+import defsort
+
+source = 'def zebra(): pass\n\ndef alpha(): pass\n'
+result = defsort.check(source)
+if result.status == 'changed':
+    source = defsort.sort(source)
+```
+
+Use `check()` to inspect skipped or invalid source before deciding what to do. The
+[library reference](docs/library.md) describes configuration, results, and the public adapter API.
+
+## Documentation
+
+| If you want to...                                   | Read                                       |
+| --------------------------------------------------- | ------------------------------------------ |
+| Choose an ordering policy and understand its limits | [Concepts and safety](docs/design.md)      |
+| Preview, apply, or automate a sort                  | [CLI reference](docs/cli.md)               |
+| Configure agent hooks or pre-commit                 | [Hook guide](docs/hook.md)                 |
+| Control reordering during adoption                  | [Incremental mode](docs/incremental.md)    |
+| Call defsort from Python                            | [Library reference](docs/library.md)       |
+| Check runtime, encoding, or path behavior           | [Platform compatibility](docs/platform.md) |
+
+## Development
+
+See the [development guide](docs/development.md) for pinned CI dependencies and lock updates.
+
+Provide the tools in `[dependency-groups].dev` through your environment or package manager.
+`make install` and `make reinstall` install only the CLI through uv.
+
+```bash
+make quality # read-only quality checks
+make check   # quality checks and one full test run
+make format  # apply repository formatters
+```
+
+To contribute an agent integration, see
+[adding a bundled agent](docs/hook.md#adding-a-bundled-agent).
+
+## License
+
+defsort is distributed under the [MIT License](LICENSE).

defsort-0.1.0/_build.py

@@ -0,0 +1,30 @@
+"""Collect bundled agent entry points for distribution metadata."""
+
+import tomllib
+from pathlib import Path
+from typing import override
+
+from hatchling.metadata.plugin.interface import MetadataHookInterface
+
+
+class PluginMetadataHook(MetadataHookInterface):
+    """Include each bundled plugin's registration in the containing distribution."""
+
+    @override
+    def update(self, metadata: dict[str, object]) -> None:
+        metadata['entry-points'] = _plugin_entry_points(Path(self.root))
+
+
+def _plugin_entry_points(root: Path) -> dict[str, dict[str, str]]:
+    """Read entry points declared by the root's agent plugin directories."""
+    groups: dict[str, dict[str, str]] = {}
+    for manifest in sorted((root / 'plugins').glob('*/adapter.toml')):
+        with manifest.open('rb') as stream:
+            entries = tomllib.load(stream)['entry-points']
+        for group, targets in entries.items():
+            registered = groups.setdefault(group, {})
+            for name, target in targets.items():
+                if name in registered:
+                    raise ValueError(f'Duplicate entry point {group}:{name} in {manifest}')
+                registered[name] = target
+    return groups

defsort-0.1.0/plugins/agy/_defsort/__init__.py

@@ -0,0 +1 @@
+"""Antigravity adapter package for defsort."""

defsort-0.1.0/plugins/agy/_defsort/_adapter.py

@@ -0,0 +1,121 @@
+"""Antigravity hook adapter."""
+
+import json
+from collections.abc import Mapping
+from typing import cast
+
+from defsort.hooks import (
+    API_VERSION,
+    HookResult,
+    HostInput,
+    HostResponse,
+    absolute_directory,
+    notes_text,
+    object_field,
+    payload_cwd,
+)
+
+_COMMAND_TOOL = 'run_command'
+_EDIT_TOOLS = frozenset({'replace_file_content', 'write_to_file'})
+_EVENTS = {'PreToolUse': 'pre_tool', 'PostToolUse': 'post_tool'}
+
+
+def _allow_response(result: HookResult) -> HostResponse:
+    """Render Antigravity allow feedback."""
+    stdout = f'{json.dumps({"systemMessage": result.reason})}\n' if result.reason else ''
+    return HostResponse(stdout, notes_text(result), 0)
+
+
+def _base_cwd(payload: Mapping[str, object], args: Mapping[str, object]) -> str:
+    """Resolve the target directory from Cwd, workspace paths, or the process."""
+    cwd = args.get('Cwd')
+    if isinstance(cwd, str) and cwd:
+        return cwd
+    workspaces = payload.get('workspacePaths')
+    if isinstance(workspaces, list):
+        first = cast('list[object]', workspaces)[:1]
+        if first and isinstance(first[0], str) and first[0]:
+            return first[0]
+    return payload_cwd(payload)
+
+
+def _deny(reason: str, stderr_prefix: str = '') -> HostResponse:
+    """Render Antigravity's top-level deny object."""
+    stdout = json.dumps({'decision': 'deny', 'reason': reason})
+    return HostResponse(f'{stdout}\n', f'{stderr_prefix}{reason}\n', 0)
+
+
+class AntigravityAdapter:
+    """Translate Antigravity tool-call payloads, which carry no event name."""
+
+    name = 'agy'
+    api_version = API_VERSION
+    requires_event = True
+
+    def parse(self, payload: Mapping[str, object], event: str | None) -> HostInput | None:
+        """Read the tool-call name and arguments under the given event.
+
+        For `run_command`, pre-tool `command_cwd` is `toolCall.args.Cwd` when
+        it is an absolute path; `workspacePaths` and the process directory are
+        never invocation evidence. Other tools report `None`.
+
+        Args:
+            payload: Decoded Antigravity hook payload.
+            event: PreToolUse or PostToolUse from the command line.
+
+        Returns:
+            Neutral input. An unrelated tool yields input with nothing to act
+            on.
+
+        Raises:
+            ValueError: If event is not an Antigravity hook event.
+        """
+        neutral_event = _EVENTS.get(event or '')
+        if neutral_event is None:
+            raise ValueError(
+                f'unknown Antigravity event {event!r}; expected PreToolUse or PostToolUse'
+            )
+        tool_call = object_field(payload, 'toolCall')
+        args = object_field(tool_call, 'args')
+        cwd = _base_cwd(payload, args)
+        name = tool_call.get('name')
+        if neutral_event == 'pre_tool':
+            command = args.get('CommandLine') if name == _COMMAND_TOOL else None
+            command_cwd = absolute_directory(args, 'Cwd') if name == _COMMAND_TOOL else None
+            return HostInput(
+                'pre_tool',
+                command if isinstance(command, str) else None,
+                cwd,
+                command_cwd,
+            )
+        editing = isinstance(name, str) and name in _EDIT_TOOLS
+        target = args.get('TargetFile') if editing else None
+        paths = (target,) if isinstance(target, str) and target else ()
+        return HostInput('post_tool', None, cwd, None, paths)
+
+    def render(self, result: HookResult) -> HostResponse:
+        """Render allow feedback or the top-level deny object.
+
+        Args:
+            result: Decision, reason, and notes from defsort.
+
+        Returns:
+            Empty stdout for a silent allow, or one system message for allow
+            feedback; notes on stderr and exit 0. For deny, the deny object on
+            stdout, the reason on stderr, and exit 0.
+        """
+        notes = notes_text(result)
+        if result.decision == 'deny':
+            return _deny(result.reason or 'defsort denied the operation', notes)
+        return _allow_response(result)
+
+    def render_failure(self, reason: str) -> HostResponse:
+        """Render the top-level deny object.
+
+        Args:
+            reason: Reason for the failure.
+
+        Returns:
+            The deny object on stdout, the reason on stderr, and exit 0.
+        """
+        return _deny(reason)

defsort-0.1.0/plugins/agy/adapter.toml

@@ -0,0 +1,2 @@
+[entry-points."defsort.hook_adapters"]
+agy = "plugins.agy._defsort._adapter:AntigravityAdapter"

defsort-0.1.0/plugins/agy/hooks.json

@@ -0,0 +1,15 @@
+{
+  "defsort": {
+    "PreToolUse": [
+      {
+        "matcher": "run_command",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "defsort hook --agent agy --event PreToolUse"
+          }
+        ]
+      }
+    ]
+  }
+}

defsort-0.1.0/plugins/agy/plugin.json

@@ -0,0 +1,5 @@
+{
+  "$schema": "https://antigravity.google/schemas/v1/plugin.json",
+  "name": "defsort-agy",
+  "description": "Install the defsort commit-time definition sorting hook for Antigravity."
+}

defsort-0.1.0/plugins/agy/tests/test_agy_adapter.py

@@ -0,0 +1,140 @@
+# pyright: reportPrivateUsage=false
+
+import json
+import shlex
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal
+
+import pytest
+
+from defsort._cli import _build_hook_parser
+from defsort.hooks import API_VERSION, HookAdapter, HookResult, HostInput, HostResponse
+from plugins.agy._defsort._adapter import AntigravityAdapter
+
+PLUGIN_ROOT = Path(__file__).resolve().parents[1]
+
+
+@dataclass(frozen=True)
+class _Result:
+    decision: Literal['allow', 'deny']
+    reason: str | None = None
+    notes: tuple[str, ...] = ()
+
+
+def _payload(tool: str, args: dict[str, object]) -> dict[str, object]:
+    return {'toolCall': {'name': tool, 'args': args}}
+
+
+def _result(
+    decision: Literal['allow', 'deny'],
+    reason: str | None = None,
+    notes: tuple[str, ...] = (),
+) -> HookResult:
+    return _Result(decision, reason, notes)
+
+
+def test_contract() -> None:
+    adapter: HookAdapter = AntigravityAdapter()
+    assert (adapter.name, adapter.api_version, adapter.requires_event) == (
+        'agy',
+        API_VERSION,
+        True,
+    )
+
+
+def test_manifest_registers_only_pre_tool_use() -> None:
+    manifest = PLUGIN_ROOT / 'hooks.json'
+    assert json.loads(manifest.read_text(encoding='utf-8')) == {
+        'defsort': {
+            'PreToolUse': [
+                {
+                    'matcher': 'run_command',
+                    'hooks': [
+                        {
+                            'type': 'command',
+                            'command': 'defsort hook --agent agy --event PreToolUse',
+                        }
+                    ],
+                }
+            ]
+        }
+    }
+    argv = shlex.split('defsort hook --agent agy --event PreToolUse')
+    args = _build_hook_parser().parse_args(argv[2:])
+    assert args.agent == 'agy'
+    assert (args.event is not None) == AntigravityAdapter.requires_event
+
+
+@pytest.mark.parametrize('tool', ['write_to_file', 'replace_file_content'])
+def test_parse_post_tool_file_writers(tool: str) -> None:
+    payload = _payload(tool, {'TargetFile': '/t/a.py', 'Cwd': '/t'})
+    assert AntigravityAdapter().parse(payload, 'PostToolUse') == HostInput(
+        'post_tool', None, '/t', None, ('/t/a.py',)
+    )
+
+
+def test_parse_pre_tool_other_tool_has_no_command() -> None:
+    payload = _payload('write_to_file', {'TargetFile': 'a.py', 'Cwd': '/t'})
+    assert AntigravityAdapter().parse(payload, 'PreToolUse') == HostInput(
+        'pre_tool', None, '/t', None
+    )
+
+
+def test_parse_rejects_unknown_event() -> None:
+    with pytest.raises(ValueError, match='unknown Antigravity event'):
+        AntigravityAdapter().parse({}, 'Stop')
+
+
+@pytest.mark.parametrize('cwd', ['rel', '', 7])
+def test_parse_run_command_non_absolute_cwd_is_unknown(cwd: object) -> None:
+    payload = _payload('run_command', {'CommandLine': 'git commit -m x', 'Cwd': cwd})
+    payload['workspacePaths'] = ['/ws']
+    parsed = AntigravityAdapter().parse(payload, 'PreToolUse')
+    assert parsed is not None
+    assert parsed.command_cwd is None
+
+
+def test_parse_run_command_prefers_cwd_over_workspace(tmp_path: Path) -> None:
+    cwd = str(tmp_path / 'command')
+    payload = _payload('run_command', {'CommandLine': 'git commit -m x', 'Cwd': cwd})
+    payload['workspacePaths'] = [str(tmp_path / 'workspace')]
+    assert AntigravityAdapter().parse(payload, 'PreToolUse') == HostInput(
+        'pre_tool', 'git commit -m x', cwd, cwd
+    )
+
+
+def test_parse_run_command_without_cwd_is_unknown() -> None:
+    payload = _payload('run_command', {'CommandLine': 'git commit -m x'})
+    payload['workspacePaths'] = ['/ws']
+    assert AntigravityAdapter().parse(payload, 'PreToolUse') == HostInput(
+        'pre_tool', 'git commit -m x', '/ws', None
+    )
+
+
+def test_plugin_manifest_uses_defsort_identity() -> None:
+    manifest = json.loads((PLUGIN_ROOT / 'plugin.json').read_text(encoding='utf-8'))
+    assert manifest == {
+        '$schema': 'https://antigravity.google/schemas/v1/plugin.json',
+        'name': 'defsort-agy',
+        'description': 'Install the defsort commit-time definition sorting hook for Antigravity.',
+    }
+
+
+def test_render_allow_and_failure() -> None:
+    assert AntigravityAdapter().render(_result('allow')) == HostResponse('', '', 0)
+    failure = AntigravityAdapter().render_failure('defsort: reason')
+    assert json.loads(failure.stdout) == {'decision': 'deny', 'reason': 'defsort: reason'}
+
+
+def test_render_allow_feedback_is_one_system_message() -> None:
+    response = AntigravityAdapter().render(_result('allow', 'first\nsecond', ('diagnostic',)))
+    assert json.loads(response.stdout) == {'systemMessage': 'first\nsecond'}
+    assert response.stderr == 'diagnostic\n'
+    assert response.exit_code == 0
+
+
+def test_render_deny_is_top_level_json() -> None:
+    response = AntigravityAdapter().render(_result('deny', 'defsort: reason', ('note',)))
+    assert json.loads(response.stdout) == {'decision': 'deny', 'reason': 'defsort: reason'}
+    assert (response.stderr, response.exit_code) == ('note\ndefsort: reason\n', 0)

defsort-0.1.0/plugins/claude/.claude-plugin/plugin.json

@@ -0,0 +1,10 @@
+{
+  "name": "defsort",
+  "version": "0.1.0",
+  "description": "Install the defsort commit-time definition sorting hook for Claude Code.",
+  "author": {
+    "name": "defsort contributors"
+  },
+  "license": "MIT",
+  "keywords": ["definitions", "dependency", "hooks", "python", "sorting"]
+}