blockwatch-cli 0.16.1__tar.gz → 0.16.2__tar.gz

blockwatch_cli-0.16.2/.agents/skills/blockwatch/SKILL.md

@@ -0,0 +1,14 @@
+---
+name: blockwatch
+description: Use when a change touches something that another place must match, such as an enum and its docs, a constant and its config, a version written in two files, or a list that must stay sorted or unique. Also use it when a file you edit holds `<block ...>` tags, or `blockwatch.toml` points at it.
+allowed-tools: Bash(blockwatch skill)
+---
+
+# blockwatch skill
+
+`blockwatch skill` prints the skill for the installed version:
+
+!`blockwatch skill`
+
+If its output is not shown above, run `blockwatch skill` and follow what it prints. If `blockwatch` is not installed,
+run `uvx --from blockwatch-cli blockwatch skill` instead.

{blockwatch_cli-0.16.1 → blockwatch_cli-0.16.2}/AGENTS.md

@@ -279,10 +279,11 @@ default), `safe` or `unsafe`.
 `src/skill.md`, `.agents/skills/blockwatch/SKILL.md` and `.claude-plugin/` are part of the *product*. They make up the
 skill this project ships, so that agents can add blocks to **other** repositories:
 
-- `src/skill.md` is the skill. `blockwatch skill` prints it with the version filled in, and users save that output in
-  their projects.
-- `.agents/skills/blockwatch/SKILL.md` is a stub for the plugin in `.claude-plugin/`. It runs `blockwatch skill` each
-  time it loads. It has its own copy of the description, and `tests/skill.rs` checks that the two copies match.
+- `src/skill.md` is the skill. `blockwatch skill` prints it with the version filled in. Its section "Installing this
+  skill" holds the stub that users save in their projects. The stub runs `blockwatch skill` each time an agent loads
+  it.
+- `.agents/skills/blockwatch/SKILL.md` is that stub, for the plugin in `.claude-plugin/`. `tests/skill.rs` checks that
+  it is the stub in `src/skill.md`, and that its description matches the one at the top of `src/skill.md`.
 
 They are not instructions for working on blockwatch, and changing them changes what users get. This file is the
 guidance for working on blockwatch.

{blockwatch_cli-0.16.1 → blockwatch_cli-0.16.2}/CHANGELOG.md

@@ -12,6 +12,34 @@ Releases up to and including v0.3.11 predate this file. Their notes live on the
 
 ## [Unreleased] - ReleaseDate
 
+## [0.16.2] - 2026-10-30
+
+### Added
+
+- Symbols in Java files. `Config.java#/Config/MAX_RETRIES` points at a field of the class `Config`, and
+  `#/Config/Mode/RED` at an enum constant. Each type is a symbol, and so is each field, method, enum constant and
+  nested type in it. A text block counts as the text Java reads, without the indentation its lines share. See
+  [Java](docs/symbols.md#java).
+- Symbols in C# files. `Config.cs#/Acme/Billing/Config/MaxRetries` points at a constant of the class `Config` in the
+  namespace `Acme.Billing`. Each type is a symbol, and so is each field, property, method, event, enum member and
+  nested type in it. A raw string counts as the text C# reads, without the white space before its closing quotes. See
+  [C#](docs/symbols.md#c).
+
+### Changed
+
+- Projects now install the agent skill as a short stub that runs `blockwatch skill` each time an agent loads it. So the
+  skill always matches the installed version. Before, projects saved the whole skill, which went stale until an agent
+  saved it again after an upgrade. A saved copy now tells the agent to replace it with the stub. See
+  [Annotating Codebases with AI Agents](docs/agents.md).
+- The agent skill now loads when a change touches something that another place must match, such as an enum and its
+  docs, or a list that must stay sorted. It also loads for files with block tags, or that `blockwatch.toml` points at.
+  Before, it loaded for every code change. This applies to the Claude Code plugin too.
+
+### Fixed
+
+- A path into a YAML file with lists or mappings nested hundreds of levels deep, such as `a: [[[...]]]`, no longer
+  crashes blockwatch with a stack overflow.
+
 ## [0.16.1] - 2026-10-28
 
 ### Added

{blockwatch_cli-0.16.1 → blockwatch_cli-0.16.2}/CLAUDE.md

@@ -279,10 +279,11 @@ default), `safe` or `unsafe`.
 `src/skill.md`, `.agents/skills/blockwatch/SKILL.md` and `.claude-plugin/` are part of the *product*. They make up the
 skill this project ships, so that agents can add blocks to **other** repositories:
 
-- `src/skill.md` is the skill. `blockwatch skill` prints it with the version filled in, and users save that output in
-  their projects.
-- `.agents/skills/blockwatch/SKILL.md` is a stub for the plugin in `.claude-plugin/`. It runs `blockwatch skill` each
-  time it loads. It has its own copy of the description, and `tests/skill.rs` checks that the two copies match.
+- `src/skill.md` is the skill. `blockwatch skill` prints it with the version filled in. Its section "Installing this
+  skill" holds the stub that users save in their projects. The stub runs `blockwatch skill` each time an agent loads
+  it.
+- `.agents/skills/blockwatch/SKILL.md` is that stub, for the plugin in `.claude-plugin/`. `tests/skill.rs` checks that
+  it is the stub in `src/skill.md`, and that its description matches the one at the top of `src/skill.md`.
 
 They are not instructions for working on blockwatch, and changing them changes what users get. This file is the
 guidance for working on blockwatch.

{blockwatch_cli-0.16.1 → blockwatch_cli-0.16.2}/Cargo.lock

@@ -274,7 +274,7 @@ checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06"
 
 [[package]]
 name = "blockwatch"
-version = "0.16.1"
+version = "0.16.2"
 dependencies = [
  "anyhow",
  "assert-json-diff",

{blockwatch_cli-0.16.1 → blockwatch_cli-0.16.2}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "blockwatch"
-version = "0.16.1"
+version = "0.16.2"
 edition = "2024"
 repository = "https://github.com/mennanov/blockwatch"
 description = "Language agnostic linter that keeps your code and documentation in sync and valid"

{blockwatch_cli-0.16.1 → blockwatch_cli-0.16.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: blockwatch-cli
-Version: 0.16.1
+Version: 0.16.2
 Summary: Language agnostic linter that keeps your code and documentation in sync and valid
 Keywords: linter,sync,drift,comments,agents
 Home-Page: https://github.com/mennanov/blockwatch

{blockwatch_cli-0.16.1 → blockwatch_cli-0.16.2}/README.md

@@ -29,7 +29,7 @@ Then paste this prompt into your AI coding agent:
 <!-- <block name="agent-prompt"> -->
 
 ```text
-Run `blockwatch skill` and save its output as `blockwatch/SKILL.md` in this project's skills directory. Then use the
+Run `blockwatch skill` and install the skill in this project as its "Installing this skill" section says. Then use the
 skill to annotate the project and add `blockwatch.toml` if needed. List each block you added and the mistake it
 catches.
 ```
@@ -37,8 +37,8 @@ catches.
 <!-- </block> -->
 
 Review the suggested blocks and commit them. The skill stays in the project, so agents working on it later know
-the rules too. When you upgrade blockwatch, the skill tells the agent to save it again. To check every future change,
-add blockwatch to your [pre-commit hook or CI](#ci-integration).
+the rules too. It runs `blockwatch skill` each time it loads, so it always matches the installed version. To check every
+future change, add blockwatch to your [pre-commit hook or CI](#ci-integration).
 
 ## How it works
 
@@ -89,7 +89,7 @@ Two validators work across files:
 - `same-as` fails when a block and its target hold different values. It needs no diff.
 
 Both can point to a block, a whole file, a specific value in a file like `package.json#/version`, a section of a
-Markdown file, or a constant in a Go, C, C++, Python, Rust, TypeScript or JavaScript file (see
+Markdown file, or a constant in a Go, C, C++, Python, Rust, TypeScript, JavaScript, Java or C# file (see
 [Symbols](docs/symbols.md)). The other validators check a single block on their own: the things you'd otherwise have to
 nitpick in code review.
 
@@ -219,7 +219,7 @@ exclusions, and custom extension mappings.
 
 ```yaml
 - repo: https://github.com/mennanov/blockwatch
-  rev: v0.16.1  # Use latest release
+  rev: v0.16.2  # Use latest release
   hooks:
     - id: blockwatch
 ```

{blockwatch_cli-0.16.1 → blockwatch_cli-0.16.2}/blockwatch.toml

@@ -39,8 +39,8 @@ same-as = '''.github/workflows/codeql.yml,
     .github/workflows/rust.yml'''
 same-as-pattern = '(?:actions/checkout@|^)(?P<value>v\d+)$'
 
-# `blockwatch skill` prints src/skill.md, and projects save that output. A tag in that file would become a block in
-# every one of those projects. So blocks point at its sections by their headings, and these entries hold the pattern
+# `blockwatch skill` prints src/skill.md, and some projects hold a saved copy of that output. A tag in that file would
+# become a block in every one of those projects. So blocks point at its sections by their headings, and these entries hold the pattern
 # that reads a section, which the section can't hold itself.
 [[block]]
 target = 'src/skill.md#/blockwatch/Validator reference'

{blockwatch_cli-0.16.1 → blockwatch_cli-0.16.2}/docs/agents.md

@@ -20,16 +20,16 @@ Paste this prompt into your agent. The agent installs the skill in your project
 <!-- <block same-as="README.md:agent-prompt"> -->
 
 ```text
-Run `blockwatch skill` and save its output as `blockwatch/SKILL.md` in this project's skills directory. Then use the
+Run `blockwatch skill` and install the skill in this project as its "Installing this skill" section says. Then use the
 skill to annotate the project and add `blockwatch.toml` if needed. List each block you added and the mistake it
 catches.
 ```
 
 <!-- </block> -->
 
-The skill stays in the project, so agents that work on it later know the rules too. It records the version of
-blockwatch that wrote it. When `blockwatch --version` prints a newer one, the skill tells the agent to save it again.
-Always inspect the generated diff before committing to ensure the added blocks are necessary and accurate.
+The agent saves a short stub, not the whole skill. The stub runs `blockwatch skill` each time it loads, so it always
+matches the installed version. It stays in the project, so agents that work on it later know the rules too. Always
+inspect the generated diff before committing to ensure the added blocks are necessary and accurate.
 
 ## 3. Enable Automated Checks
 
@@ -52,21 +52,20 @@ The plugin's skill runs `blockwatch skill` each time it loads, so it always matc
 
 ### Other AI Tools
 
-For other environments or project-local setups, save the output of `blockwatch skill` to the expected skill location:
+To set up a project by hand, save the stub from
+[Installing this skill](../src/skill.md#installing-this-skill) where your agent reads it:
 
 | Agent               | Location                                               |
 |---------------------|--------------------------------------------------------|
 | **Claude Code**     | Plugin (above) or `.claude/skills/blockwatch/SKILL.md` |
 | **Cursor**          | `.cursor/rules/blockwatch.mdc`                         |
-| **GitHub Copilot**  | Append to `.github/copilot-instructions.md`            |
-| **Codex / generic** | Append to `AGENTS.md`                                  |
+| **GitHub Copilot**  | `.github/copilot-instructions.md`                      |
+| **Codex / generic** | `AGENTS.md`                                            |
 
-For example, for Claude Code:
+`.github/copilot-instructions.md` and `AGENTS.md` hold other instructions too. Add only the stub's description there,
+and the sentence "Then run `blockwatch skill` and follow what it prints."
 
-```shell
-mkdir -p .claude/skills/blockwatch
-blockwatch skill > .claude/skills/blockwatch/SKILL.md
-```
+Don't save the output of `blockwatch skill` itself. A saved copy goes stale when blockwatch is upgraded.
 
 ---
 

{blockwatch_cli-0.16.1 → blockwatch_cli-0.16.2}/docs/ci.md

@@ -19,7 +19,7 @@ To use [pre-commit](https://pre-commit.com), add the hook to `.pre-commit-config
 
 ```yaml
 - repo: https://github.com/mennanov/blockwatch
-  rev: v0.16.1  # Use latest release
+  rev: v0.16.2  # Use latest release
   hooks:
     - id: blockwatch
 ```
@@ -59,7 +59,7 @@ The `blockwatch` hook runs before the commit message exists, so it cannot see a
 
 ```yaml
 - repo: https://github.com/mennanov/blockwatch
-  rev: v0.16.1  # Use latest release
+  rev: v0.16.2  # Use latest release
   hooks:
     - id: blockwatch-commit-msg
 ```

{blockwatch_cli-0.16.1 → blockwatch_cli-0.16.2}/docs/cli.md

@@ -557,15 +557,15 @@ Nothing else about the run changes: the same violations are found, and the exit
       "tool": {
         "driver": {
           "name": "blockwatch",
-          "version": "0.16.1",
-          "semanticVersion": "0.16.1",
+          "version": "0.16.2",
+          "semanticVersion": "0.16.2",
           "informationUri": "https://github.com/mennanov/blockwatch",
           "rules": [
             {
               "id": "keep-sorted",
               "name": "keep-sorted",
               "shortDescription": { "text": "Requires the lines of a block to stay in order." },
-              "helpUri": "https://github.com/mennanov/blockwatch/blob/v0.16.1/docs/validators/keep-sorted.md"
+              "helpUri": "https://github.com/mennanov/blockwatch/blob/v0.16.2/docs/validators/keep-sorted.md"
             }
           ]
         }
@@ -980,14 +980,9 @@ stay on stderr, under the same file paths and line numbers.
 add value, how to write them, and how to check its work. The text is built into the binary, so it always matches the
 installed version. The command works in any directory, even outside a repository.
 
-Save it into your agent's skills directory:
-
-```shell
-blockwatch skill > .claude/skills/blockwatch/SKILL.md
-```
-
-The saved skill records the version that wrote it. When `blockwatch --version` prints a newer one, the skill tells the
-agent to save it again. See [Annotating Codebases with AI Agents](agents.md).
+Don't save the output itself, because a saved copy goes stale when blockwatch is upgraded. Save the stub from the
+[Installing this skill](../src/skill.md#installing-this-skill) section instead. The stub runs `blockwatch skill` each
+time an agent loads it. See [Annotating Codebases with AI Agents](agents.md).
 
 ## Exit Codes
 

{blockwatch_cli-0.16.1 → blockwatch_cli-0.16.2}/docs/symbols.md

@@ -37,6 +37,8 @@ declares, instead of tags in a comment.
 | Rust       | `.rs`                                                                          | [Rust](#rust)                                           |
 | TypeScript | `.ts`, `.mts`, `.cts`, `.d.ts`, `.tsx`                                         | [TypeScript and JavaScript](#typescript-and-javascript) |
 | JavaScript | `.js`, `.mjs`, `.cjs`, `.jsx`                                                  | [TypeScript and JavaScript](#typescript-and-javascript) |
+| Java       | `.java`                                                                        | [Java](#java)                                           |
+| C#         | `.cs`                                                                          | [C#](#c)                                                |
 
 <!-- </block> -->
 
@@ -247,7 +249,8 @@ Clone the repository.
 
 In a code file, each top-level name is a symbol: a constant, a variable, a type, a function or a macro. Its path is
 `#/NAME`.
-With `const MaxPorts = 8` in `consts.go`, `consts.go#/MaxPorts` points at `8`.
+With `const MaxPorts = 8` in `consts.go`, `consts.go#/MaxPorts` points at `8`. In Java and C#, the members of a type
+are symbols too, under the type's name: `Config.java#/Config/MAX_PORTS`.
 
 - **A value is the initializer as written.** blockwatch never works it out: `20 * 1024 * 1024` stays as it is, and so
   does `0x10`. Use `same-as-pattern` to take the part you need.
@@ -257,10 +260,11 @@ With `const MaxPorts = 8` in `consts.go`, `consts.go#/MaxPorts` points at `8`.
 - **A symbol covers its own definition**, keywords included, but not the comments above it. `affects` counts a change
   to that text only.
 - **A name defined twice is a violation**, because blockwatch can't tell which copy you mean.
-- **A syntax error stops the run only for the names near it**: a name whose definition holds the error, and any name in
-  the text that the parser had to skip. Other names in the file still resolve. The message shows where the error is.
-- **A string that blockwatch can't decode stops the run** for its name only.
-- **Members are not symbols yet**, such as a method or a field.
+- **A syntax error stops the run only for the names near it**: a name whose definition holds the error, and every path
+  with a name from the text that the parser had to skip. Other names in the file still resolve. The message shows
+  where the error is.
+- **A path to a string that blockwatch can't decode stops the run.** Other paths in the file still resolve.
+- **Members are not symbols yet**, such as a method or a field, except in Java and C#.
 
 <!-- </block> -->
 
@@ -298,7 +302,7 @@ func Helper() {}
 - **Names get their values by position.** In `var x, y = f()`, one call gives both names, so neither has a value.
 - **A type is not part of a value.** `const X Mode = 3` is `3`.
 - **Strings follow Go's escapes.** `"\xc3\xa9"` is `é`. A raw string loses its carriage returns. A rune, such as `'r'`,
-  stays as written. A string whose bytes are not UTF-8 text stops the run for its name.
+  stays as written. A path to a string whose bytes are not UTF-8 text stops the run.
 - **Methods, `func init` and `_` are not symbols.**
 - **`go.mod`, `go.sum` and `go.work` have no symbols.**
 
@@ -386,7 +390,7 @@ def load(path):
   value: `type Pair[T] = tuple[T, T]` is `#/Pair`.
 - **Strings follow Python's escapes.** `"\xe9"` is `é`. An escape Python doesn't know, such as `\d`, stays as written.
   A raw string is its text. An f-string without a field is its text, with `{{` as `{`. An f-string with a field and
-  bytes stay as written. A `\N{...}` escape stops the run for its name.
+  bytes stay as written. A path to a string with a `\N{...}` escape stops the run.
 - **Starlark files, such as `BUILD` and `.bzl`, follow the same rules.** A rule call, such as
   `cc_library(name = "lib")`, is not a symbol.
 - **Class members are not symbols yet.**
@@ -471,12 +475,126 @@ function normalize(text: string): string {
 - **Imports, `export { ... }`, `const { a } = b`, `module.exports`, an anonymous `export default` and `_` are not
   symbols.**
 - **Strings follow JavaScript's escapes.** `"\uD83D\uDE00"` is `😀`. A template without `${...}` is its text. A template
-  with a field and a tagged template, such as ``String.raw`a` ``, stay as written. A legacy escape, such as `\07`,
-  stops the run for its name.
+  with a field and a tagged template, such as ``String.raw`a` ``, stay as written. A path to a string with a legacy
+  escape, such as `\07`, stops the run.
 - **Enum members, class members and the contents of a namespace are not symbols yet.**
 
 <!-- </block> -->
 
+## Java
+
+<!-- <block name="java-paths"> -->
+
+```java
+public class Config {
+    @Native
+    public static final int MAX_RETRIES = 20 * 1024;
+    static final String QUERY = """
+        SELECT *
+        FROM t
+        """;
+
+    void run() {}
+    void run(int times) {}
+
+    enum Mode { RED, GREEN }
+
+    static class Limits {
+        static final long ID = 0x10L;
+    }
+}
+```
+
+| Path                   | Points at                                     |
+|------------------------|-----------------------------------------------|
+| `#/Config`             | the whole class                               |
+| `#/Config/MAX_RETRIES` | `20 * 1024`                                   |
+| `#/Config/QUERY`       | `SELECT *` and `FROM t`, on two lines         |
+| `#/Config/run`         | a violation, as `run` is defined twice        |
+| `#/Config/Mode/GREEN`  | `GREEN`, as it has no value                   |
+| `#/Config/Limits/ID`   | `0x10L`                                       |
+
+- **Each type is a symbol, and so is each member in it**: a field, a method, an enum constant, an annotation element
+  or a nested type. A path goes from the top-level type down, as code refers to it: `#/Config/Limits/ID`.
+- **Overloads are defined twice, and so are a field and a method with one name**, such as `name` and `name()`. Wrap the
+  one you mean in a block instead.
+- **Annotations are part of a definition. Javadoc is not.** In `int a = 1, b = 2;`, a name covers only its own part.
+- **An annotation element's value is its `default`.** `String value() default "x";` is `x`.
+- **A method without a body, such as one in an interface, is a symbol.**
+- **Constructors, initializer blocks, record components, local and anonymous classes, and the members in the body of an
+  enum constant are not symbols.** An accessor you write in a record, such as `int x()`, is a method.
+- **A file with methods and fields at its top level, as Java 25 allows, gives them paths such as `#/main`.**
+- **Strings follow Java's escapes.** `"caf\u00e9"` is `café`. A text block counts as the text Java reads, without the
+  indentation its lines share and the white space at the ends of its lines. A character, such as `'a'`, and a string
+  template stay as written. A path to a string with `\u005c` stops the run. Java turns `\u005c` into a backslash
+  before it reads the other escapes, so `"\u005cn"` is `"\n"`.
+- **A syntax error stops the run for the member that holds it, and for each type around that member.** The other
+  members still resolve.
+
+<!-- </block> -->
+
+## C\#
+
+<!-- <block name="c-sharp-paths"> -->
+
+```csharp
+namespace Acme.Billing;
+
+public class Config
+{
+    [Obsolete]
+    public const int MaxRetries = 20 * 1024;
+    public static readonly string Query = """
+        SELECT *
+        FROM t
+        """;
+    public string Name { get; set; } = "default";
+    public static string Url => $"https://{Host}/x";
+
+    void Run() {}
+    void Run(int times) {}
+
+    public enum Mode { Red = 1, Green }
+
+    class Limits { const long Id = 0x10L; }
+}
+```
+
+| Path                               | Points at                              |
+|------------------------------------|----------------------------------------|
+| `#/Acme/Billing/Config`            | the whole class                        |
+| `#/Acme/Billing/Config/MaxRetries` | `20 * 1024`                            |
+| `#/Acme/Billing/Config/Query`      | `SELECT *` and `FROM t`, on two lines  |
+| `#/Acme/Billing/Config/Name`       | `default`                              |
+| `#/Acme/Billing/Config/Url`        | `$"https://{Host}/x"`, as written      |
+| `#/Acme/Billing/Config/Run`        | a violation, as `Run` is defined twice |
+| `#/Acme/Billing/Config/Mode/Green` | `Green`, as it has no value            |
+| `#/Acme/Billing/Config/Limits/Id`  | `0x10L`                                |
+
+- **A namespace is part of the path, but not a symbol.** `namespace Acme.Billing { }` and
+  `namespace Acme { namespace Billing { } }` give the same paths as `namespace Acme.Billing;`. `#/Acme/Billing` alone
+  is not found. A type outside any namespace starts at the top: `#/Config/MaxRetries`.
+- **Each type is a symbol, and so is each member in it**: a field, a constant, a property, a method, an event, an enum
+  member or a nested type. Classes, structs, interfaces, enums, records and delegates are types.
+- **Overloads are defined twice.** So are the copies of a name in `#if` and `#else`, and `Cache` next to `Cache<T>`,
+  as a path has no place for `<T>`. A member that only one of them has still resolves. Wrap the one you mean in a
+  block instead.
+- **A property's value is the one it starts with**: `v` in `X { get; set; } = v;` and in `X => v;`. A method has no
+  value, even with `=> v`.
+- **Attributes are part of a definition. `///` comments are not.** In `int a = 1, b = 2;`, a name covers only its own
+  part. The code in `#if`, `#elif` and `#else` counts as if the directives were not there.
+- **A name written with `@` keeps it**: `#/Config/@switch`.
+- **Constructors, finalizers, indexers, operators, explicit interface members such as `void IDisposable.Dispose()`,
+  record parameters and top-level statements are not symbols.** A property you write in a record's body is a symbol.
+- **Strings follow C#'s escapes.** A verbatim string, such as `@"C:\temp"`, has none. A raw string counts as the text
+  C# reads, without the white space before its closing quotes. `$"v1"` is `v1`. A string with a hole, such as
+  `$"v{Major}"`, stays as written, and so do `"abc"u8` and a character such as `'a'`. A path to a string that C#
+  rejects stops the run, such as `"\?"` or a raw string with a line less indented than its closing quotes.
+- **A syntax error stops the run for the member that holds it, and for each type around that member.** The other
+  members still resolve.
+
+<!-- </block> -->
+
 ---
 
 [← Return to README](../README.md)

{blockwatch_cli-0.16.1 → blockwatch_cli-0.16.2}/setup.py

@@ -6,7 +6,7 @@ setup(
     name='blockwatch-pre-commit-placeholder',
     version='0.0.0',
     # <block name="blockwatch-cli-version" same-as-pattern="blockwatch-cli==(?P<value>\d+\.\d+\.\d+)">
-    install_requires=['blockwatch-cli==0.16.1'],
+    install_requires=['blockwatch-cli==0.16.2'],
     # </block>
     # Without it, setuptools takes the directories under src/ for Python packages.
     packages=[],

{blockwatch_cli-0.16.1 → blockwatch_cli-0.16.2}/src/language_parsers/c.rs

@@ -158,6 +158,7 @@ fn top_level_definitions<'tree>(
         "alias_declaration" => node
             .child_by_field_name("name")
             .map(|name| Definition {
+                parents: Vec::new(),
                 names: vec![name],
                 range: start..node.end_byte(),
                 value: None,
@@ -202,6 +203,7 @@ fn declaration_definitions(declaration: Node<'_>, start: usize) -> Vec<Definitio
             continue;
         }
         definitions.push(Definition {
+            parents: Vec::new(),
             names: vec![name],
             range: if alone {
                 start..declaration.end_byte()
@@ -242,6 +244,7 @@ fn typedef_definitions<'tree>(
     let mut definitions = Vec::new();
     if !names.is_empty() {
         definitions.push(Definition {
+            parents: Vec::new(),
             names,
             range: start..typedef.end_byte(),
             value: None,
@@ -256,6 +259,7 @@ fn typedef_definitions<'tree>(
 fn function_definition(function: Node<'_>, start: usize) -> Option<Definition<'_>> {
     let (name, _) = declared_name(function.child_by_field_name("declarator")?)?;
     Some(Definition {
+        parents: Vec::new(),
         names: vec![name],
         range: start..function.end_byte(),
         value: None,
@@ -267,6 +271,7 @@ fn function_definition(function: Node<'_>, start: usize) -> Option<Definition<'_
 fn type_definitions(specifier: Node<'_>, start: usize) -> Vec<Definition<'_>> {
     let mut definitions: Vec<Definition> = defined_type_name(specifier)
         .map(|name| Definition {
+            parents: Vec::new(),
             names: vec![name],
             range: start..specifier.end_byte(),
             value: None,
@@ -302,6 +307,7 @@ fn enumerators(specifier: Node<'_>) -> Vec<Definition<'_>> {
         .filter(|child| child.kind() == "enumerator")
         .filter_map(|enumerator| {
             Some(Definition {
+                parents: Vec::new(),
                 names: vec![enumerator.child_by_field_name("name")?],
                 range: enumerator.byte_range(),
                 value: enumerator
@@ -364,6 +370,7 @@ fn macro_definition<'tree>(
     // The node holds the line end after the macro.
     let end = node.start_byte() + node_text(&node, source).trim_end().len();
     Ok(Some(Definition {
+        parents: Vec::new(),
         names: vec![name],
         range: node.start_byte()..end,
         value,