ruff-sync 0.1.4.dev0__tar.gz → 0.1.5__tar.gz

ruff_sync-0.1.5/.agents/DEPENDENCIES.md

@@ -0,0 +1,47 @@
+# Optional Dependencies & Lazy Loading
+
+To keep the `ruff-sync` CLI fast and lightweight, while still allowing for extensible features (like a TUI or specialized formatters), we use a standardized pattern for **Optional Dependencies**.
+
+## Requirements
+
+1. **Defensive Coding**: The application must never crash at startup if an optional dependency is missing. Instead, it should fail gracefully ONLY when the specific feature requiring that dependency is invoked.
+2. **Delayed Import Cycles**: We must avoid expensive imports of optional dependencies during the initial CLI application boot.
+3. **User-Friendly Errors**: If a dependency is missing, we must provide clear instructions on how the user can install it using `ruff-sync` extras.
+
+## Standard Pattern
+
+All code that relies on an optional dependency MUST follow this pattern:
+
+### 1. Define the Extra in `pyproject.toml`
+
+Add the dependency to the `[project.optional-dependencies]` section.
+
+```toml
+[project.optional-dependencies]
+tui = ["textual>=8.2.2"]
+```
+
+### 2. Check and Lazy-Import (Locally)
+
+Never import optional dependencies at the top level of a module. All imports must happen inside the function or method that requires them, AFTER a defensive check.
+
+```python
+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
+    ...
+```
+
+## The Dependency Helper (`ruff_sync.dependencies`)
+
+Use the utilities in `src/ruff_sync/dependencies.py` to handle these checks.
+
+- `is_installed(package_name: str) -> bool`: A fast check using `importlib.util.find_spec` that doesn't trigger the package initialization.
+- `require_dependency(package_name: str, extra_name: str) -> None`: Checks if a package is installed and raises a helpful `ImportError` if it is not.
+
+### Example ImportError
+> "The 'textual' package is required for this feature. Install it with: pip install 'ruff-sync[tui]'"

{ruff_sync-0.1.4.dev0 → ruff_sync-0.1.5}/.agents/TESTING.md

@@ -8,7 +8,7 @@ This document defines the mandatory testing standards and patterns for the `ruff
 - **No Side Effects**: Tests must be isolated and not touch the actual filesystem or make real network calls.
 - **Semantic + Structural Assertions**: When testing TOML merges, always verify **both**:
   1. **Structural/Whitespace**: The file "looks" correct (comments and spacing are preserved).
-  2. **Semantic**: The actual data in the merged result matches the expected values.
+  2. **Semantic**: The actual data in the merged result matches the expected values. Use the [dirty-equals](skills/dirty-equals/SKILL.md) Agent Skill for declarative, concise assertions.
 - **DRY with Fixtures and Parameterization**: Avoid code duplication. Use fixtures for common setups and `@pytest.mark.parametrize` for matrix testing.
 
 ## 2. Tooling and Environment
@@ -130,6 +130,6 @@ def test_my_edge_case():
 
 ## 6. Code Coverage
 
-We target **high coverage** for `ruff_sync.py`.
+We target **high coverage** for `src/ruff_sync/`.
 - Run coverage locally: `uv run coverage run -m pytest -vv && uv run coverage report`
 - New features MUST include unit tests in `tests/test_basic.py` or specialized files like `tests/test_whitespace.py` if they involve formatting logic.

ruff_sync-0.1.5/.agents/decisions/0001-type-refactoring-strategy.md

@@ -0,0 +1,36 @@
+# ADR 0001: Type Refactoring Strategy
+
+---
+status: accepted
+date: 2026-04-05
+decider: Agent
+---
+
+## Context
+
+The `ruff-sync` codebase, particularly the TUI and TOML merging logic, has historically relied on `dict[str, Any]` and deep `isinstance` checks. This makes the codebase difficult to maintain, prone to runtime errors, and provides poor IDE support.
+
+Based on the establishing `type-checking` skill, we need a strategic approach to "Complexity Shifting" and "Healthy Abstraction".
+
+## Decision
+
+We will implement a multi-phase type-refactoring strategy:
+
+1.  **Eliminate unstructured `dict[str, Any]`**: Introduce `TypedDict` for core payloads (Ruff rules, linters) in the TUI and System modules.
+2.  **Polymorphic TUI Widgets**: Replace recursive `isinstance(data, dict/list)` chains in widgets with structural polymorphism (e.g., `@singledispatchmethod` or a dedicated Node AST).
+3.  **Strategic Complexity (High-ROI typing)**: Apply strict typing (`tomlkit` bounds) to core infrastructure like `core.py` (TOML merging) while keeping feature code simple.
+4.  **Result Type Patterns**: Shift away from `Union[Success, Error]` with `isinstance` checks towards robust `Result` or tuple patterns.
+
+## Consequences
+
+- **Pros**:
+    - Improved static analysis via `mypy`.
+    - Better developer experience (autocompletion, go-to-definition).
+    - Reduced runtime "surprises" in complex TOML merges.
+- **Cons**:
+    - Initial "complexity tax" in core infrastructure types.
+    - Requires wrapping raw TOML data into structured nodes before rendering.
+
+## References
+
+- [type-checking skill](../skills/type-checking/SKILL.md)

ruff_sync-0.1.5/.agents/decisions/0002-tui-node-ast.md

@@ -0,0 +1,36 @@
+# ADR 0002: TUI Node AST Architecture
+
+---
+status: accepted
+date: 2026-04-05
+decider: Agent
+---
+
+## Context
+
+The TUI's configuration rendering (`widgets.py`) and selection logic (`app.py`) rely heavily on nested `isinstance` checks to navigate raw `dict`/`list` structures. This breaks down as the TOML structure becomes more complex (dotted keys, custom tables, list-of-tables).
+
+We need a way to shift "rendering complexity" into "data structure complexity" using the polymorphism principle from ADR 0001.
+
+## Decision
+
+We will implement a polymorphic **ConfigNode AST** for the TUI:
+
+1.  **`ConfigNode` Protocol**: A baseline interface (`path()`, `key()`, `children()`, `doc_target()`).
+2.  **Concrete Nodes**: `DictNode`, `ListNode`, `ScalarNode`, `LinterNode`, and `RulesCollectionNode`.
+3.  **Recursive Wrapping**: A `wrap_data()` factory that converts raw TOML data into a `ConfigNode` tree during initial load.
+4.  **UI-Layer Polymorphism**: Use `@singledispatchmethod` in widgets (e.g., `CategoryTable.render_node(node)`) to route rendering logic based on the node type, keeping Rich markup out of the model layer.
+
+## Consequences
+
+- **Pros**:
+    - Centralized documentation routing (`doc_target()`).
+    - Widgets no longer need to know "what" they are rendering, only "how" to render a `ConfigNode`.
+    - Eliminates fragile nested type-inference logic.
+- **Cons**:
+    - Requires an additional "wrapping" step during data load.
+    - Slightly more boilerplate in `src/ruff_sync/tui/types_.py`.
+
+## References
+
+- [ADR 0001: Type Refactoring Strategy](./0001-type-refactoring-strategy.md)

ruff_sync-0.1.5/.agents/decisions/README.md

@@ -0,0 +1,11 @@
+# ADR Index
+
+This is an internal record of architectural decisions for `ruff-sync`. These documents capture the historical "Why" for design choices made by both human and agentic developers.
+
+| ID | Date | Status | Title |
+| --- | --- | --- | --- |
+| [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 |
+
+---
+*For instructions on how to create or manage ADRs, see the [ADR Skill](../skills/adr/SKILL.md).*

ruff_sync-0.1.5/.agents/doc-fix.md

@@ -0,0 +1,160 @@
+# Fix Versioned Documentation CI (`mike` + MkDocs)
+
+## Summary
+
+After researching the official `mike` README, Material for MkDocs docs, and comparing against real-world projects, the current setup has **one fatal flaw** and several secondary problems that have caused versioning to never work correctly.
+
+---
+
+## Root Cause: Two Workflows Fighting Each Other
+
+The most critical issue is that **two separate workflows both deploy docs to `gh-pages` on every push to `main`**, and they use incompatible methods:
+
+| Workflow | Trigger | Command | Effect |
+|---|---|---|---|
+| `ci.yaml` → `publish-docs` | push to `main` | `mike deploy --push dev` | Appends a `dev/` directory and `versions.json` to `gh-pages` |
+| `docs.yaml` → `deploy` | push to `main` | `mkdocs gh-deploy --force` | **Completely overwrites the entire `gh-pages` branch** |
+
+`mkdocs gh-deploy --force` does not know about `mike`. It builds a flat site and force-pushes it as the **sole content** of `gh-pages`. This destroys everything `mike` deployed, including `versions.json`, the `dev/` subdirectory, and the root redirect.
+
+**This is why versioning has never worked: `docs.yaml` immediately destroys `mike`'s work.**
+
+---
+
+## Secondary Issues
+
+### 1. Wrong `alias_type` in `mkdocs.yml`
+- `alias_type: copy` is set, but for GitHub Pages `redirect` is the most reliable option. `copy` creates full file copies for every alias, meaning the `stable` alias contains a complete separate copy of docs that becomes stale when the `stable` alias moves. `symlink` is the default and works on most servers, but GitHub Pages does not follow actual symlinks. `redirect` creates a thin HTML redirect per page at the alias path — the correct approach for GitHub Pages.
+
+### 2. Invalid `mike alias --push stable stable` bootstrap
+- The CI attempts `mike alias --push stable stable` to "ensure `stable` exists." This is nonsensical — it tries to create an alias called `stable` pointing to `stable` (which doesn't exist yet). Mike will error, and the `|| true` suppresses it. It achieves nothing.
+
+### 3. `mike deploy --update-aliases dev` on stable releases
+- When releasing `0.1.4 stable`, the CI also runs `mike deploy --push --update-aliases dev`. This re-deploys the current commit as *both* the stable `0.1.4` and the `dev` version, which makes `dev` identical to `stable`. `dev` should only be updated on commits to `main` when the version is a dev pre-release.
+
+### 4. The `validate-docs-build` job is fine but could use `--no-directory-urls`
+- `mkdocs build --strict` is a good validation step on PRs. No change needed.
+
+---
+
+## Proposed Changes
+
+### [`DELETE`] `.github/workflows/docs.yaml`
+
+This file is the root cause. It must be deleted. All documentation deployment must happen exclusively through `mike` in `ci.yaml`.
+
+---
+
+### [`MODIFY`] `.github/workflows/ci.yaml` — `publish-docs` job
+
+**Fix the deploy logic:**
+
+```yaml
+publish-docs:
+  name: Publish Documentation
+  if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+  needs: [pre-publish]
+  runs-on: ubuntu-latest
+  permissions:
+    contents: write
+  steps:
+    - name: Checkout
+      uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+
+    - name: Fetch gh-pages branch
+      # mike needs the gh-pages branch history to make incremental commits.
+      # Without this, mike may fail or corrupt the branch.
+      run: git fetch origin gh-pages --depth=1 || true
+
+    - name: Install uv
+      uses: astral-sh/setup-uv@v5
+
+    - name: Set up Python
+      run: uv python install 3.10
+
+    - name: Install dependencies
+      run: uv sync --group docs --frozen
+
+    - name: Configure git
+      run: |
+        git config user.name "github-actions[bot]"
+        git config user.email "github-actions[bot]@users.noreply.github.com"
+
+    - name: Extract version
+      id: version
+      run: |
+        VERSION=$(uv run python -c "
+        import pathlib, tomlkit
+        data = tomlkit.parse(pathlib.Path('pyproject.toml').read_text(encoding='utf-8'))
+        version = data.get('project', {}).get('version') or data.get('version')
+        if not version: raise SystemExit('Version not found')
+        print(version)
+        ")
+        echo "version=$VERSION" >> $GITHUB_OUTPUT
+        echo "Current Version: $VERSION"
+
+    - name: Deploy dev documentation
+      if: contains(steps.version.outputs.version, '.dev')
+      run: uv run mike deploy --push --update-aliases dev
+
+    - name: Deploy stable documentation
+      if: "!contains(steps.version.outputs.version, '.dev')"
+      run: |
+        VERSION="${{ steps.version.outputs.version }}"
+        uv run mike deploy --push --update-aliases "$VERSION" stable
+        uv run mike set-default --push stable
+```
+
+**Key changes from current:**
+1. Added `git fetch origin gh-pages --depth=1 || true` — required by mike to make incremental commits (per the mike README CI section).
+2. Split the version extraction into its own step with `id: version` so it can be used in `if` conditions.
+3. `dev` is **only** deployed when the version string contains `.dev`. The stable deploy no longer also writes a `dev` alias.
+4. Removed the bogus `mike alias --push stable stable || true` bootstrap.
+
+---
+
+### [`MODIFY`] `mkdocs.yml` — Fix `alias_type`
+
+Change `alias_type` from `copy` to `redirect`:
+
+```yaml
+plugins:
+  - mike:
+      alias_type: redirect   # was: copy
+      canonical_version: stable
+```
+
+`redirect` is the correct choice for GitHub Pages: it creates a lightweight `.html` redirect file at the alias path for every page (e.g., `stable/index.html` redirects to `0.1.4/index.html`). Unlike `symlink`, it works reliably on GitHub Pages. Unlike `copy`, it doesn't create diverging stale copies.
+
+---
+
+### [`MODIFY`] `.agents/skills/mike/SKILL.md`
+
+- Remove the failed repair history section (no longer relevant once fixed)
+- Update the CI workflow documentation to reflect the corrected single-workflow approach
+- Document the critical `git fetch origin gh-pages --depth=1` requirement
+- Document why `docs.yaml` must not exist alongside `mike deploy`
+- Update `alias_type` guidance from `copy` to `redirect`
+
+---
+
+## Verification Plan
+
+### After merging:
+1. Check that `docs.yaml` is deleted and only `ci.yaml` deploys docs.
+2. Watch the next CI run on `main` — the `publish-docs` job should run `mike deploy --push --update-aliases dev`.
+3. Check the `gh-pages` branch: it should contain a `dev/` directory, a `versions.json`, and a root `index.html` redirect.
+4. Visit `https://kilo59.github.io/ruff-sync/` — it should redirect to `dev/` (since no stable version has been deployed yet).
+5. The version selector in the Material theme should appear showing `dev`.
+
+### For stable releases:
+When version is bumped to a non-dev release and merged:
+- `0.x.y/` directory appears on `gh-pages`
+- `stable` alias points to `0.x.y/` via redirects
+- Root redirects to `stable/`
+- Version selector shows both `0.x.y [stable]` and `dev`
+
+> [!IMPORTANT]
+> After deploying, you may need to manually run a one-time `mike deploy --push dev` locally (or trigger the CI) to bootstrap the `gh-pages` branch if it currently contains a flat `mkdocs gh-deploy` dump. You may first want to run `mike delete --all --push` to wipe the broken state.

ruff_sync-0.1.5/.agents/ruff.toml

@@ -0,0 +1,37 @@
+# Agents-specific ruff linter overrides.
+# This configuration applies to all files within the .agents/ directory.
+#
+# WHY AGENT SCRIPTS ARE TREATED DIFFERENTLY:
+# ------------------------------------------
+# 1. Faster iteration: Agent-related code (skills, scripts, and examples) is
+#    often experimental, short-lived, or used for automation.
+# 2. Lower maintenance: We relax requirements like module-level docstrings
+#    to maintain speed and reduce boilerplate.
+# 3. Local use: These scripts are usually run locally by the agent or developer
+#    rather than being part of the core production library.
+# 4. Prototyping: Allowing assert statements (S101) makes it easier to write
+#    concise validation for specialized agent workflows.
+# 5. Usage context for examples: We disable rules that move imports into
+#    if TYPE_CHECKING blocks because skill examples may be integrated into
+#    other applications in ways we cannot predict. Runtime access to
+#    imported objects is preserved to ensure compatibility with various
+#    application patterns (decorators, runtime reflection, etc).
+
+# Inherit root linter settings from the project's pyproject.toml.
+extend = "../pyproject.toml"
+
+[lint]
+# Specific overrides for agent python code, scripts, and skills.
+extend-ignore = [
+    "D100",   # missing-docstring-in-module - Agent scripts don't require module-level docstrings.
+    "D103",   # missing-docstring-in-public-function - Agent functions don't require public docstrings.
+    "S101",   # assert-statement - Asserts are preferred over other validation for internal agent scripts.
+
+    # Preserve runtime access for standalone examples and unknown integration:
+    # Disable rules that move imports into if TYPE_CHECKING: blocks.
+    "TC001",  # Move third-party import into a type-checking block
+    "TC002",  # Move third-party import into a type-checking block
+    "TC003",  # Move second-party import into a type-checking block
+    "TC004",  # Move first-party import into a type-checking block
+    "TC005",  # Move standard library import into a type-checking block
+]

ruff_sync-0.1.5/.agents/skills/adr/SKILL.md

@@ -0,0 +1,66 @@
+# ADR (Architectural Decision Record) Skill
+
+## Overview
+
+Use this skill to capture, manage, and reference significant architectural decisions for `ruff-sync`. ADRs are stored internally in `.agents/decisions/` and provide a historical record of "Why" things are designed the way they are.
+
+## When to Create an ADR
+
+Create an ADR when:
+- A significant architectural change is proposed (e.g., new internal AST, changing the merging strategy).
+- A long-running refactoring strategy is initiated (e.g., the Type-Checking Refactoring).
+- A decision is made that will impact future development and needs to be "remembered" by future agent sessions.
+- A "Implementation Plan" has been approved and reaches a level of architectural significance that warrants long-term persistence.
+
+## ADR Structure
+
+Each ADR should be named `NNNN-slug.md` (e.g., `0001-type-refactoring-strategy.md`) and located in `.agents/decisions/`.
+
+> [!IMPORTANT]
+> **Use relative paths for ALL internal links.** Never use absolute paths (`file:///Users/...`) as they are machine-specific and break in different environments.
+
+Use the following template:
+
+```markdown
+# ADR [NNNN]: [Short Title]
+
+---
+status: [proposed | accepted | superseded | deprecated]
+date: YYYY-MM-DD
+decider: [Agent | User]
+---
+
+## Context
+
+What is the problem we are trying to solve? What are the constraints?
+
+## Decision
+
+What are we doing? Be specific about the architectural shift.
+
+## Consequences
+
+What are the trade-offs? What will be easier? What will be harder?
+
+## References
+
+- Links to PRs or Issues (use `gh-issues` skill).
+- Links to other ADRs (e.g., "Supersedes [NNNN]").
+- Links to implementation plans or research.
+```
+
+## Workflows
+
+### 1. Creating a New ADR
+1. Identify the need for a persistent architectural record.
+2. Draft the ADR in `.agents/decisions/` using the next available number.
+3. Update `.agents/decisions/README.md` with the new entry.
+4. Reference the ADR in `AGENTS.md` if it represents a foundational shift.
+
+### 2. Superseding an ADR
+1. Create the new ADR (e.g., `0005`).
+2. Mark the old ADR (e.g., `0002`) as `status: superseded`.
+3. Add a link in the old ADR's `References` to the new one, and vice versa.
+
+### 3. Graduation
+Implementation plans in `.agents/` are often temporary. When a plan is completed, if its decisions are architecturally significant, "graduate" it by distilling its core decisions into an ADR.

ruff_sync-0.1.5/.agents/skills/dirty-equals/SKILL.md

@@ -0,0 +1,37 @@
+---
+name: dirty-equals
+description: Use this skill when you need to write declarative, readable, and maintainable assertions in Python tests. It is particularly effective for matching complex data structures, validating merged TOML configurations, and performing fuzzy matching on URLs, file paths, or object types. Use this when the user asks to "assert," "check," "verify," or "match" data in a test, even if they don't explicitly mention "dirty-equals."
+---
+
+# `dirty-equals` Skill
+
+This skill provides patterns and best practices for writing declarative assertions in the `ruff-sync` project using the `dirty-equals` library.
+
+## Overview
+
+Instead of asserting on every field manually, compare against a "dirty" object that matches the expected structure and types.
+
+```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),
+    })
+```
+
+## Detailed reference
+
+Check these references for project-specific usage and common matchers:
+
+- **[Common Matchers](references/common-matchers.md)**: Standard `dirty-equals` matchers like `IsPartialDict`, `IsInstance`, and more.
+- **[Specialized Matching](references/toml-matching.md)**: Handling `tomlkit.unwrap()` and `Arguments._asdict()`.
+
+## Best Practices
+
+- **Import Style**: Always use the `from dirty_equals import ...` style at the **module level** of your test files.
+- **Semantic Matching**: Use `dirty-equals` for the semantic part of your test assertions, while using string comparisons or `respx` for structural/whitespace checks where appropriate.
+- **Type Safety**: Prefer `IsInstance(httpx.URL)` or `IsInstance(pathlib.Path)` over custom regex for well-known types in the project.

ruff_sync-0.1.5/.agents/skills/dirty-equals/references/common-matchers.md

@@ -0,0 +1,51 @@
+# Common `dirty-equals` Matchers
+
+This guide covers the most frequently used `dirty-equals` matchers in the `ruff-sync` project. Standard practice is to import these using the `from` syntax at the module level in test files.
+
+## Structural Matching
+
+- **`IsPartialDict`**: Matches a subset of a dictionary. Essential for verifying specific fields in a larger configuration.
+- **`IsDict`**: Matches an entire dictionary exactly (while still allowing fuzzy values).
+- **`IsList`**: Matches a list, allowing fuzzy matching for elements.
+
+## Type and Instance Matching
+
+- **`IsInstance(type)`**: Matches an object of a specific class. Used for objects like `httpx.URL` or `pathlib.Path`.
+- **`IsStr()`**: Matches any string. Can also specify regex or prefix/suffix.
+- **`IsInt()`**: Matches any integer.
+
+## Examples
+
+### Using `IsPartialDict` and `IsInstance`
+
+```python
+from dirty_equals import IsInstance, IsPartialDict
+import httpx
+import pathlib
+
+# Match a partial dict with mixed types
+assert response_data == IsPartialDict({
+    "url": IsInstance(httpx.URL),
+    "status": "success",
+    "retries": 0,
+})
+```
+
+### String and Path Matching
+
+```python
+from dirty_equals import IsInstance, IsStr
+import pathlib
+
+# Match a path instance
+assert result_path == IsInstance(pathlib.Path)
+
+# Match a string with a specific prefix
+assert error_message == IsStr(regex="^ERROR:.*")
+```
+
+## Logic Matchers
+
+- **`~` (Negation)**: Match values that are *not* the given value (e.g., `assert x == ~IsNone`).
+- **`&` (AND)**: Combine matchers (e.g., `IsInt & IsPositive`).
+- **`|` (OR)**: Combine alternatives.

ruff_sync-0.1.5/.agents/skills/dirty-equals/references/toml-matching.md

@@ -0,0 +1,54 @@
+# Specialized Matching for `ruff-sync`
+
+This reference covers project-specific data structures where `dirty-equals` matchers require particular preparation for reliable results.
+
+## TOML Matching (`tomlkit`)
+
+`tomlkit` returns proxy objects (containers and items). To reliably match these with `dirty-equals`, always use `.unwrap()` on the parsed document or table to convert it to plain Python types.
+
+### Correct Pattern
+
+```python
+from dirty_equals import IsPartialDict
+import tomlkit
+
+# Parse some TOML
+doc = tomlkit.parse('[tool.ruff]\nline-length = 80')
+
+# Match the tool.ruff section
+ruff_config = doc["tool"]["ruff"]
+
+# Must use .unwrap()
+assert ruff_config.unwrap() == IsPartialDict({"line-length": 80})
+```
+
+### Potential Gotcha
+Direct matching of `tomlkit` proxy objects without `.unwrap()` can fail because `dirty-equals` may see the proxy's internal attributes rather than its data.
+
+## CLI `Arguments` matching
+
+Our CLI arguments are defined as a `NamedTuple`. To match specific fields without validating the entire object, convert it to a dictionary using `._asdict()`.
+
+### Correct Pattern
+
+```python
+from dirty_equals import IsInstance, IsPartialDict
+import httpx
+import pathlib
+import ruff_sync_cli
+
+# Sample Arguments instance
+args = ruff_sync_cli.Arguments(
+    command="pull",
+    upstream=(httpx.URL("https://example.com"),),
+    to=pathlib.Path("."),
+    # ... other defaults ...
+)
+
+# Convert to dict and match specific fields
+assert args._asdict() == IsPartialDict({
+    "command": "pull",
+    "upstream": (IsInstance(httpx.URL),),
+    "to": IsInstance(pathlib.Path),
+})
+```

ruff_sync-0.1.5/.agents/skills/dirty-equals/trigger_eval.json

@@ -0,0 +1,30 @@
+[
+  {
+    "query": "I need to check if the tool.ruff section was merged correctly",
+    "should_trigger": true
+  },
+  {
+    "query": "add a unit test that verifies the output",
+    "should_trigger": true
+  },
+  {
+    "query": "where should I use dirty-equals",
+    "should_trigger": true
+  },
+  {
+    "query": "verify that this URL is from github.com",
+    "should_trigger": true
+  },
+  {
+    "query": "assert that the dictionary matches this schema",
+    "should_trigger": true
+  },
+  {
+    "query": "fix this syntax error in the CLI",
+    "should_trigger": false
+  },
+  {
+    "query": "run the tests with coverage",
+    "should_trigger": false
+  }
+]