ruff-sync 0.1.7.dev2__tar.gz → 0.1.9.dev0__tar.gz

{ruff_sync-0.1.7.dev2 → ruff_sync-0.1.9.dev0}/.agents/DEPENDENCIES.md

@@ -29,10 +29,12 @@ Never import optional dependencies at the top level of a module. All imports mus
 def run_tui_feature():
     # 1. First, check availability (fast, lightweight)
     from ruff_sync.dependencies import require_dependency
+
     require_dependency("textual", extra_name="tui")
 
     # 2. Then, perform local import (delayed expensive cycle)
     from textual.app import App
+
     ...
 ```
 

{ruff_sync-0.1.7.dev2 → ruff_sync-0.1.9.dev0}/.agents/args_refactor_plan.md

@@ -96,11 +96,11 @@ class ExecutionArgs(NamedTuple):
     semantic: bool
     diff: bool
     init: bool
-    pre_commit: bool      # plain bool — MISSING resolved to default
+    pre_commit: bool  # plain bool — MISSING resolved to default
     save: bool | None
     output_format: OutputFormat
-    validate: bool        # plain bool — MISSING resolved to default
-    strict: bool          # plain bool — MISSING resolved to default
+    validate: bool  # plain bool — MISSING resolved to default
+    strict: bool  # plain bool — MISSING resolved to default
 ```
 
 > [!NOTE]
@@ -120,9 +120,9 @@ class Arguments(NamedTuple):
     def resolve(self) -> ExecutionArgs:
         """Resolve all MISSING sentinels to their effective defaults for execution."""
         _, _, _, eff_validate, eff_strict, eff_pre_commit = resolve_defaults(
-            MISSING,   # branch — already resolved, pass MISSING to skip
-            MISSING,   # path — already resolved, pass MISSING to skip
-            MISSING,   # exclude — already resolved, pass MISSING to skip
+            MISSING,  # branch — already resolved, pass MISSING to skip
+            MISSING,  # path — already resolved, pass MISSING to skip
+            MISSING,  # exclude — already resolved, pass MISSING to skip
             self.validate,
             self.strict,
             self.pre_commit,
@@ -205,11 +205,14 @@ Replace the `resolve_defaults()` call in `Arguments.resolve()` with `resolve_boo
 ```python
 from ruff_sync.constants import resolve_bool_flags
 
+
 class Arguments(NamedTuple):
     # ...
     def resolve(self) -> ExecutionArgs:
         eff_validate, eff_strict, eff_pre_commit = resolve_bool_flags(
-            self.validate, self.strict, self.pre_commit,
+            self.validate,
+            self.strict,
+            self.pre_commit,
         )
         return ExecutionArgs(
             command=self.command,
@@ -291,7 +294,7 @@ call is actually redundant. However, if the function is also used by code that p
 async def _merge_multiple_upstreams(
     target_doc: TOMLDocument,
     is_target_ruff_toml: bool,
-    args: ExecutionArgs,     # ← changed from Arguments
+    args: ExecutionArgs,  # ← changed from Arguments
     client: httpx.AsyncClient,
 ) -> TOMLDocument:
     # No resolve_defaults() needed — args already has plain values
@@ -363,17 +366,20 @@ Add **new** tests for `resolve_bool_flags()`:
 ```python
 from ruff_sync.constants import resolve_bool_flags
 
+
 def test_resolve_bool_flags_all_missing():
     validate, strict, pre_commit = resolve_bool_flags(MISSING, MISSING, MISSING)
     assert validate is False
     assert strict is False
     assert pre_commit is True
 
+
 def test_resolve_bool_flags_strict_implies_validate():
     validate, strict, pre_commit = resolve_bool_flags(MISSING, True, MISSING)
     assert validate is True
     assert strict is True
 
+
 def test_resolve_bool_flags_explicit_false():
     validate, strict, pre_commit = resolve_bool_flags(False, False, False)
     assert validate is False

{ruff_sync-0.1.7.dev2 → ruff_sync-0.1.9.dev0}/.agents/cli_animation_plan.md

@@ -441,9 +441,7 @@ def recordings(ctx, tape=None):
         tape_files = [tape_file]
     else:
         # Process all tape files except _common.tape
-        tape_files = sorted(
-            f for f in tapes_dir.glob("*.tape") if not f.name.startswith("_")
-        )
+        tape_files = sorted(f for f in tapes_dir.glob("*.tape") if not f.name.startswith("_"))
 
     if not tape_files:
         print("⚠️ No tape files found in tapes/")

ruff_sync-0.1.9.dev0/.agents/decisions/0004-httpx2-respx-test-aliasing.md

@@ -0,0 +1,51 @@
+# ADR 0004: httpx2 Integration, Respx Mocking, and Test-Guarded Process Aliasing
+
+---
+status: accepted
+date: 2026-07-25
+decider: Kilo59 / Agent
+---
+
+## Context & Motivation for Switching to `httpx2`
+
+`ruff-sync` relies on an asynchronous HTTP client to pull upstream Ruff linter configurations from GitHub and GitLab repositories.
+
+We migrated from `httpx` to **`httpx2`** based on the official rationale provided by **Pydantic Services**:
+- **Active Stewardship & Security Maintenance**: Due to a significant period of reduced maintenance activity and inactivity on the original `httpx` package, Pydantic Services created `httpx2` as an actively maintained successor to guarantee timely security updates, bug fixes, and continuous maintenance for a critical core library in the Python ecosystem.
+- **Ecosystem Continuity**: The "2" in `httpx2` functions as a versioning marker for this new era of Pydantic Services maintenance rather than a breaking paradigm rewrite, preserving full compatibility while delivering active upstream support.
+- **Strict Typing**: `httpx2` provides first-class typing out of the box, integrating cleanly with our `mypy` strict mode requirements.
+
+Previously, HTTP test mocking relied on the third-party `pytest-httpx2` plugin. We needed to clean up our HTTP dependencies, eliminate `pytest-httpx2`, and migrate to standard `respx` (`>=0.23.1`) while ensuring zero side-effects on production execution.
+
+## Decision
+
+1. **Direct Application Imports**: Application runtime code (`src/ruff_sync/core.py`) imports `httpx2` directly (`import httpx2 as httpx`).
+2. **Elimination of `pytest-httpx2`**: We completely removed `pytest-httpx2` from dependencies due to confusion and transport hook coupling.
+3. **Test-Guarded Process Aliasing (`src/sitecustomize.py`)**: We place `httpx2.alias_httpx()` inside `src/sitecustomize.py` guarded by a runtime check (`any("pytest" in arg for arg in sys.argv) or "PYTEST_CURRENT_TEST" in os.environ`).
+
+## Rationale & Technical Tradeoffs
+
+### 1. Removal of `pytest-httpx2`
+Beyond introducing transport hook conflicts and entrypoint ordering bugs, `pytest-httpx2` caused developer confusion:
+- `pytest-httpx2` is a wrapper around `respx`, but its name frequently leads developers to the documentation for `pytest-httpx` / `httpx_pytest`.
+- This created confusion around fixture names, routing syntax, and unexpected mocking behavior.
+Eliminating `pytest-httpx2` removes this confusing wrapper layer and standardizes our test suite directly on `respx`.
+
+### 2. No Production HTTP Plugin Dependencies
+`ruff-sync` runtime code does **not** depend on third-party `httpcore` or `httpx` plugins in production.
+If our production runtime relied on external plugins that hard-coded `import httpx` or `import httpcore`, we would require process-wide aliasing at production application startup. Because `ruff-sync` manages its HTTP transport directly via `httpx2`, aliasing is only necessary during test suite execution when `respx` is loaded by Pytest.
+
+### 3. Packaging Exclusion
+`src/sitecustomize.py` lives outside `src/ruff_sync/` and is strictly excluded from wheel packages by Hatchling (`packages = ["src/ruff_sync"]`). Published `.whl` and `sdist` distributions never include or ship `sitecustomize.py` to end users.
+
+### 4. Why Disabling `respx` Autoloading (`-p no:respx`) Is a Gnarly Upstream Problem
+We evaluated disabling `respx` entrypoint autoloading via `addopts = ["-p", "no:respx"]` and manually declaring `pytest_plugins = ["respx"]` in `conftest.py`. However, this reveals a gnarly entrypoint race condition:
+- `respx` registers a `pytest11` entrypoint that imports `httpx`/`httpcore` at plugin discovery time.
+- Disabling `respx` autoloading and re-enabling it via `pytest_plugins` causes `respx` to initialize its `MockRouter` hooks *after* Python module resolution has settled. In end-to-end CLI tests where `httpx2.AsyncClient` is instantiated across sub-threads or CLI entrypoints, `httpx2` creates fresh `httpcore2` transport instances that bypass `respx`'s delayed transport hooks, causing `RESPX: some routes were not called!` errors.
+- **Upstream Resolution Needed**: This conflict needs to be resolved **upstream** — either in `respx` (by deferring transport binding until active router context rather than entrypoint import time) or in `httpx2` (by providing native `httpcore2` transport interceptors for `respx` without requiring `sys.modules` aliasing). Until fixed upstream, `sitecustomize.py` is the only mechanism that forces `alias_httpx()` to run at Python interpreter launch before Pytest's entrypoint scanner initializes `respx`.
+
+## References
+
+- [ADR Index](./README.md)
+- [httpx2 Migration Guide](https://httpx2.pydantic.dev/migration/)
+- [Issue #202](https://github.com/Kilo59/ruff-sync/issues/202) / [PR #203](https://github.com/Kilo59/ruff-sync/pull/203)

{ruff_sync-0.1.7.dev2 → ruff_sync-0.1.9.dev0}/.agents/decisions/README.md

@@ -7,6 +7,7 @@ This is an internal record of architectural decisions for `ruff-sync`. These doc
 | [0001](./0001-type-refactoring-strategy.md) | 2026-04-05 | Accepted | Type Refactoring Strategy |
 | [0002](./0002-tui-node-ast.md) | 2026-04-05 | Accepted | TUI Node AST Architecture |
 | [0003](./0003-argument-resolution-layers.md) | 2026-04-10 | Accepted | Two-Layer Argument Resolution (Transport vs Execution) |
+| [0004](./0004-httpx2-respx-test-aliasing.md) | 2026-07-25 | Accepted | httpx2 Integration, Respx Mocking, and Test-Guarded Process Aliasing |
 
 ---
 *For instructions on how to create or manage ADRs, see the [ADR Skill](../skills/adr/SKILL.md).*

{ruff_sync-0.1.7.dev2 → ruff_sync-0.1.9.dev0}/.agents/formatters-architecture.md

@@ -58,8 +58,8 @@ def error(
     message: str,
     file_path: pathlib.Path | None = None,
     logger: logging.Logger | None = None,
-    check_name: str = "ruff-sync/config-drift",   # machine-readable rule ID
-    drift_key: str | None = None,                  # e.g. "lint.select"
+    check_name: str = "ruff-sync/config-drift",  # machine-readable rule ID
+    drift_key: str | None = None,  # e.g. "lint.select"
 ) -> None: ...
 ```
 
@@ -107,11 +107,11 @@ this even when `UpstreamError` or another exception occurs.
 1. **Add the format value** to `OutputFormat` in `src/ruff_sync/constants.py`:
    ```python
    class OutputFormat(str, enum.Enum):
-       TEXT   = "text"
-       JSON   = "json"
+       TEXT = "text"
+       JSON = "json"
        GITHUB = "github"
        GITLAB = "gitlab"
-       SARIF  = "sarif"   # new
+       SARIF = "sarif"  # new
    ```
 
 2. **Implement the class** in `src/ruff_sync/formatters.py`.  For a
@@ -151,7 +151,7 @@ fmt = get_formatter(args.output_format)
 try:
     ...
 finally:
-    fmt.finalize()   # no-op for streaming; flushes JSON for accumulating
+    fmt.finalize()  # no-op for streaming; flushes JSON for accumulating
 ```
 
 `finalize()` is always called unconditionally — **do not** guard it with
@@ -168,6 +168,7 @@ is newly introduced or already resolved between branches.
 ```python
 import hashlib
 
+
 def _make_fingerprint(upstream_url: str, local_file: str, drift_key: str | None) -> str:
     if drift_key:
         raw = f"ruff-sync:drift:{upstream_url}:{local_file}:{drift_key}"

{ruff_sync-0.1.7.dev2 → ruff_sync-0.1.9.dev0}/.agents/gitlab-reports.md

@@ -145,6 +145,7 @@ For a "config drift" issue per key (e.g., `lint.select`), a good stable fingerpr
 ```python
 import hashlib
 
+
 def make_fingerprint(upstream_url: str, local_file: str, drift_key: str) -> str:
     """Stable fingerprint for a config drift issue."""
     raw = f"ruff-sync:drift:{upstream_url}:{local_file}:{drift_key}"
@@ -281,13 +282,15 @@ class GitlabFormatter:
         fingerprint: str | None = None,
     ) -> None:
         (logger or LOGGER).error(message)
-        self._issues.append(self._make_issue(
-            description=message,
-            check_name=check_name,
-            severity="major",
-            file_path=file_path,
-            fingerprint=fingerprint,
-        ))
+        self._issues.append(
+            self._make_issue(
+                description=message,
+                check_name=check_name,
+                severity="major",
+                file_path=file_path,
+                fingerprint=fingerprint,
+            )
+        )
 
     def warning(
         self,
@@ -298,13 +301,15 @@ class GitlabFormatter:
         fingerprint: str | None = None,
     ) -> None:
         (logger or LOGGER).warning(message)
-        self._issues.append(self._make_issue(
-            description=message,
-            check_name=check_name,
-            severity="minor",
-            file_path=file_path,
-            fingerprint=fingerprint,
-        ))
+        self._issues.append(
+            self._make_issue(
+                description=message,
+                check_name=check_name,
+                severity="minor",
+                file_path=file_path,
+                fingerprint=fingerprint,
+            )
+        )
 
     def _make_issue(
         self,
@@ -327,6 +332,7 @@ class GitlabFormatter:
     @staticmethod
     def _auto_fingerprint(description: str, path: str) -> str:
         import hashlib
+
         raw = f"ruff-sync:drift:{path}:{description}"
         return hashlib.md5(raw.encode()).hexdigest()
 
@@ -370,7 +376,7 @@ class OutputFormat(str, enum.Enum):
     TEXT = "text"
     JSON = "json"
     GITHUB = "github"
-    GITLAB = "gitlab"   # NEW
+    GITLAB = "gitlab"  # NEW
 ```
 
 Update `get_formatter` in `formatters.py`:
@@ -530,7 +536,7 @@ fmt = get_formatter(args.output_format)
 try:
     ...
 finally:
-    fmt.finalize()   # Writes the JSON array to stdout (piped to file by CI)
+    fmt.finalize()  # Writes the JSON array to stdout (piped to file by CI)
 ```
 
 **Do not** guard the call with `isinstance` or `hasattr` checks.
@@ -562,6 +568,7 @@ from unittest.mock import patch
 
 from ruff_sync.formatters import GitlabFormatter
 
+
 def test_gitlab_formatter_empty_on_no_issues(capsys):
     fmt = GitlabFormatter()
     fmt.finalize()
@@ -569,6 +576,7 @@ def test_gitlab_formatter_empty_on_no_issues(capsys):
     issues = json.loads(captured.out)
     assert issues == []
 
+
 def test_gitlab_formatter_error_produces_major_issue(capsys):
     fmt = GitlabFormatter()
     fmt.error("drift found", file_path=pathlib.Path("pyproject.toml"))
@@ -581,6 +589,7 @@ def test_gitlab_formatter_error_produces_major_issue(capsys):
     assert issues[0]["location"]["lines"]["begin"] == 1
     assert "fingerprint" in issues[0]
 
+
 def test_gitlab_formatter_fingerprint_is_stable(capsys):
     fmt1 = GitlabFormatter()
     fmt2 = GitlabFormatter()
@@ -594,6 +603,7 @@ def test_gitlab_formatter_fingerprint_is_stable(capsys):
     issues2 = json.loads(out2)
     assert issues1[0]["fingerprint"] == issues2[0]["fingerprint"]
 
+
 def test_gitlab_formatter_no_bom(capsys):
     fmt = GitlabFormatter()
     fmt.finalize()

{ruff_sync-0.1.7.dev2 → ruff_sync-0.1.9.dev0}/.agents/issue-102-context.md

@@ -17,8 +17,18 @@ class ResultFormatter(Protocol):
     def note(self, message: str) -> None: ...
     def info(self, message: str, logger: logging.Logger | None = None) -> None: ...
     def success(self, message: str) -> None: ...
-    def error(self, message: str, file_path: pathlib.Path | None = None, logger: logging.Logger | None = None) -> None: ...
-    def warning(self, message: str, file_path: pathlib.Path | None = None, logger: logging.Logger | None = None) -> None: ...
+    def error(
+        self,
+        message: str,
+        file_path: pathlib.Path | None = None,
+        logger: logging.Logger | None = None,
+    ) -> None: ...
+    def warning(
+        self,
+        message: str,
+        file_path: pathlib.Path | None = None,
+        logger: logging.Logger | None = None,
+    ) -> None: ...
     def debug(self, message: str, logger: logging.Logger | None = None) -> None: ...
     def diff(self, diff_text: str) -> None: ...
 ```

{ruff_sync-0.1.7.dev2 → ruff_sync-0.1.9.dev0}/.agents/plans/issue-116-config-validation.md

@@ -88,6 +88,7 @@ def validate_toml_syntax(doc: TOMLDocument) -> bool:
     """
     try:
         import tomlkit  # already a dep
+
         tomlkit.parse(doc.as_string())
         return True
     except Exception:  # noqa: BLE001
@@ -146,9 +147,7 @@ def validate_ruff_accepts_config(doc: TOMLDocument, is_ruff_toml: bool = False)
             )
             return False
         except FileNotFoundError:
-            LOGGER.warning(
-                "⚠️  `ruff` not found on PATH — skipping Ruff config validation."
-            )
+            LOGGER.warning("⚠️  `ruff` not found on PATH — skipping Ruff config validation.")
             return True  # Soft fail: don't block if ruff isn't installed
         except subprocess.TimeoutExpired:
             LOGGER.warning("⚠️  Ruff config validation timed out — skipping.")
@@ -184,7 +183,7 @@ Validation is **opt-in**. Before touching `core.py`, wire up the CLI flag.
 class Arguments(NamedTuple):
     ...
     validate: bool = False  # run --validate checks before writing
-    strict: bool = False    # treat warnings as errors (implies validate)
+    strict: bool = False  # treat warnings as errors (implies validate)
 ```
 
 **In `common_parser`** (around line 236), add:
@@ -230,18 +229,17 @@ Open `core.py`. Find the `pull()` function (around line 1103). Look for this blo
 **After** this block (and **before** `should_save = args.save ...`), insert:
 
 ```python
-        # Validation is opt-in — only run if --validate (or --strict) was passed
-        if args.validate:
-            is_ruff_toml = is_ruff_toml_file(_source_toml_path.name)
-            from ruff_sync.validation import validate_merged_config  # noqa: PLC0415
-            if not validate_merged_config(
-                source_doc, is_ruff_toml=is_ruff_toml, strict=args.strict
-            ):
-                fmt.error(
-                    "❌ Merged config failed validation. Local file left unchanged.",
-                    logger=LOGGER,
-                )
-                return 1
+# Validation is opt-in — only run if --validate (or --strict) was passed
+if args.validate:
+    is_ruff_toml = is_ruff_toml_file(_source_toml_path.name)
+    from ruff_sync.validation import validate_merged_config  # noqa: PLC0415
+
+    if not validate_merged_config(source_doc, is_ruff_toml=is_ruff_toml, strict=args.strict):
+        fmt.error(
+            "❌ Merged config failed validation. Local file left unchanged.",
+            logger=LOGGER,
+        )
+        return 1
 ```
 
 > **Note**: The inline import avoids a circular import issue if `validation.py` ever needs to
@@ -437,6 +435,7 @@ Add to `tests/test_config_validation.py`:
 ```python
 def test_version_consistency_warn_on_mismatch(caplog: pytest.LogCaptureFixture) -> None:
     import logging
+
     doc = tomlkit.parse(
         '[project]\nrequires-python = ">=3.10"\n\n[tool.ruff]\ntarget-version = "py39"\n'
     )
@@ -492,9 +491,7 @@ def _get_deprecated_rule_codes() -> frozenset[str]:
         if result.returncode != 0:
             return frozenset()
         rules = json.loads(result.stdout)
-        return frozenset(
-            r["code"] for r in rules if r.get("deprecated") is True
-        )
+        return frozenset(r["code"] for r in rules if r.get("deprecated") is True)
     except (FileNotFoundError, subprocess.TimeoutExpired, json.JSONDecodeError, KeyError):
         return frozenset()
 ```
@@ -573,7 +570,9 @@ def check_deprecated_rules(
     is_ruff_toml: bool = False,
     _deprecated_codes: frozenset[str] | None = None,
 ) -> None:
-    deprecated_codes = _deprecated_codes if _deprecated_codes is not None else _get_deprecated_rule_codes()
+    deprecated_codes = (
+        _deprecated_codes if _deprecated_codes is not None else _get_deprecated_rule_codes()
+    )
     ...
 ```
 

{ruff_sync-0.1.7.dev2 → ruff_sync-0.1.9.dev0}/.agents/skills/dirty-equals/SKILL.md

@@ -14,13 +14,16 @@ Instead of asserting on every field manually, compare against a "dirty" object t
 ```python
 from dirty_equals import IsInt, IsPartialDict, IsStr
 
+
 def test_config_logic():
     result = {"status": "active", "version": 1, "extra": "data"}
     # Declarative assertion
-    assert result == IsPartialDict({
-        "status": IsStr(regex="act.*"),
-        "version": IsInt(gt=0),
-    })
+    assert result == IsPartialDict(
+        {
+            "status": IsStr(regex="act.*"),
+            "version": IsInt(gt=0),
+        }
+    )
 ```
 
 ## Detailed reference

{ruff_sync-0.1.7.dev2 → ruff_sync-0.1.9.dev0}/.agents/skills/dirty-equals/references/common-matchers.md

@@ -24,11 +24,13 @@ import httpx
 import pathlib
 
 # Match a partial dict with mixed types
-assert response_data == IsPartialDict({
-    "url": IsInstance(httpx.URL),
-    "status": "success",
-    "retries": 0,
-})
+assert response_data == IsPartialDict(
+    {
+        "url": IsInstance(httpx.URL),
+        "status": "success",
+        "retries": 0,
+    }
+)
 ```
 
 ### String and Path Matching

{ruff_sync-0.1.7.dev2 → ruff_sync-0.1.9.dev0}/.agents/skills/dirty-equals/references/toml-matching.md

@@ -13,7 +13,7 @@ from dirty_equals import IsPartialDict
 import tomlkit
 
 # Parse some TOML
-doc = tomlkit.parse('[tool.ruff]\nline-length = 80')
+doc = tomlkit.parse("[tool.ruff]\nline-length = 80")
 
 # Match the tool.ruff section
 ruff_config = doc["tool"]["ruff"]
@@ -46,9 +46,11 @@ args = ruff_sync_cli.Arguments(
 )
 
 # Convert to dict and match specific fields
-assert args._asdict() == IsPartialDict({
-    "command": "pull",
-    "upstream": (IsInstance(httpx.URL),),
-    "to": IsInstance(pathlib.Path),
-})
+assert args._asdict() == IsPartialDict(
+    {
+        "command": "pull",
+        "upstream": (IsInstance(httpx.URL),),
+        "to": IsInstance(pathlib.Path),
+    }
+)
 ```

{ruff_sync-0.1.7.dev2/.agents/skills/ruff-sync-usage → ruff_sync-0.1.9.dev0/.agents/skills/ruff-sync}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: ruff-sync-usage
+name: ruff-sync
 description: >-
   Configure and operate ruff-sync to synchronize Ruff linter settings across Python projects.
   Use when the user wants to set up ruff-sync, sync Ruff config from an upstream source,

{ruff_sync-0.1.7.dev2 → ruff_sync-0.1.9.dev0}/.agents/skills/textual/SKILL.md

@@ -14,8 +14,10 @@ from __future__ import annotations
 from textual.app import App, ComposeResult
 from textual.widgets import Header, Footer, Static
 
+
 class SimpleApp(App[None]):
     """A minimal Textual app."""
+
     BINDINGS = [("q", "quit", "Quit")]
 
     def compose(self) -> ComposeResult:
@@ -23,6 +25,7 @@ class SimpleApp(App[None]):
         yield Static("Hello, [bold blue]Textual[/bold blue]!")
         yield Footer()
 
+
 if __name__ == "__main__":
     SimpleApp().run()
 ```

{ruff_sync-0.1.7.dev2 → ruff_sync-0.1.9.dev0}/.agents/skills/textual/references/events.md

@@ -33,6 +33,7 @@ Define `reactive` attributes to automatically trigger updates. Use `watch_<attri
 ```python
 from textual.reactive import reactive
 
+
 class Counter(Static):
     # Reactive state: UI updates whenever 'count' is modified
     count: reactive[int] = reactive(0)
@@ -52,6 +53,8 @@ Widgets can communicate with parents via custom messages:
 1. **Define a Message**:
    ```python
    from textual.message import Message
+
+
    class DataLoaded(Message):
        def __init__(self, data: list[str]) -> None:
            self.data = data

{ruff_sync-0.1.7.dev2 → ruff_sync-0.1.9.dev0}/.agents/skills/textual/references/testing.md

@@ -10,6 +10,7 @@ Use the `pilot` object to interact with your app in a headless state.
 import pytest
 from my_app import SimpleApp
 
+
 @pytest.mark.asyncio
 async def test_button_click():
     app = SimpleApp()

{ruff_sync-0.1.7.dev2 → ruff_sync-0.1.9.dev0}/.agents/skills/textual/references/widgets.md

@@ -82,6 +82,7 @@ Modals are screens with a transparent or dim background that overlay the main ap
 from textual.screen import ModalScreen
 from textual.app import App
 
+
 class OmniboxScreen(ModalScreen[str]):
     # A modal screen that returns a `str` when dismissed.
     def compose(self) -> ComposeResult:
@@ -92,11 +93,13 @@ class OmniboxScreen(ModalScreen[str]):
     def on_input_submitted(self, event: Input.Submitted) -> None:
         self.dismiss(event.value)
 
+
 # In the main App or Screen:
 def on_key(self, event: events.Key) -> None:
     if event.key == "ctrl+p":
         self.push_screen(OmniboxScreen(), self.handle_omnibox_result)
 
+
 def handle_omnibox_result(self, result: str | None) -> None:
     if result:
         print(f"Selected: {result}")

{ruff_sync-0.1.7.dev2 → ruff_sync-0.1.9.dev0}/.agents/skills/type-checking/references/advanced-narrowing.md

@@ -19,9 +19,11 @@ Use `TypeIs` when you want to definitively split a Union.
 from typing import Union
 from typing_extensions import TypeIs
 
+
 def is_str(val: Union[str, int]) -> TypeIs[str]:
     return isinstance(val, str)
 
+
 def process(val: Union[str, int]) -> None:
     if is_str(val):
         # Mypy knows val is str
@@ -39,10 +41,12 @@ Use `@runtime_checkable Protocol` with `TypeIs` for structural subtyping.
 from typing import Protocol, runtime_checkable
 from typing_extensions import TypeIs
 
+
 @runtime_checkable
 class Reader(Protocol):
     def read(self) -> str: ...
 
+
 def is_reader(val: object) -> TypeIs[Reader]:
     return isinstance(val, Reader)
 ```

{ruff_sync-0.1.7.dev2 → ruff_sync-0.1.9.dev0}/.agents/skills/type-checking/references/error-code-lookup.md

@@ -17,8 +17,8 @@ Match the Mypy error code from your terminal to the project-safe resolution patt
 
 **Bad (Cast)**:
 ```python
-val = get_union() # str | None
-val.upper()       # [union-attr] "None" has no attribute "upper"
+val = get_union()  # str | None
+val.upper()  # [union-attr] "None" has no attribute "upper"
 # NO: val = cast(str, val)
 ```
 
@@ -26,7 +26,7 @@ val.upper()       # [union-attr] "None" has no attribute "upper"
 ```python
 val = get_union()
 if val is not None:
-    val.upper() # FIXED
+    val.upper()  # FIXED
 ```
 
 ### Fixing `[assignment]` (Dealing with `tomlkit` or `Any`)
@@ -34,7 +34,7 @@ if val is not None:
 **Bad (Cast)**:
 ```python
 doc = tomlkit.parse(...)
-tool: Table = doc["tool"] # [assignment] Incompatible types (Item vs Table)
+tool: Table = doc["tool"]  # [assignment] Incompatible types (Item vs Table)
 # NO: tool = cast(Table, doc["tool"])
 ```
 
@@ -52,8 +52,10 @@ if not isinstance(tool, Table):
 **Bad (Cast)**:
 ```python
 def process_str(s: str): ...
+
+
 data: Union[str, int] = ...
-process_str(data) # [arg-type] Argument 1 has incompatible type
+process_str(data)  # [arg-type] Argument 1 has incompatible type
 # NO: process_str(cast(str, data))
 ```
 
@@ -61,9 +63,11 @@ process_str(data) # [arg-type] Argument 1 has incompatible type
 ```python
 from typing_extensions import TypeIs
 
+
 def is_str(v: object) -> TypeIs[str]:
     return isinstance(v, str)
 
+
 if is_str(data):
-    process_str(data) # FIXED
+    process_str(data)  # FIXED
 ```