Please address the comments from this code review:

## Overall Comments
- In `preprocess-node-types.py` you're reaching into the private `NodeTypeParser._registration_cache`; consider exposing a public method or property to retrieve the registration cache so the build script isn't coupled to an internal attribute that may change.
- The pickle written by `preprocess-node-types.py` stores both `things` and `registration_cache`, but `_load_from_cache` only consumes `registration_cache`; either load and reuse the precomputed `things` as well or drop them from the cache payload to avoid unnecessary file size and confusion about what is actually used.
- In `get_version()` the code now silently falls back to `"0.0.0"` when `git describe` fails; consider logging a debug or warning message in that branch so unexpected version resolution failures are visible during debugging.

## Individual Comments

### Comment 1
<location> `scripts/build/preprocess-node-types.py:36-42` </location>
<code_context>
+    print(f"  Parsed {len(all_things)} Things/Categories across all languages")
+
+    # Get the cache from the parser's internal registry
+    cache_data = {
+        "things": all_things,
+        "registration_cache": parser._registration_cache,
+    }
+
</code_context>

<issue_to_address>
**suggestion (performance):** Consider whether storing `things` in the cache is necessary given the current load path.

Right now the cache includes both `"things"` and `"registration_cache"`, but `_load_from_cache` only reads `registration_cache`. If `things` isn’t used elsewhere, you can remove it from the cache to shrink the pickle and avoid serializing large data unnecessarily.

If you expect to load `things` from the cache later, consider adding a comment or assertion in `_load_from_cache` to document that contract and keep the cache shape intentional.

```suggestion
    print(f"  Parsed {len(all_things)} Things/Categories across all languages")

    # Only persist the parser's registration cache. The Thing/Category objects
    # are reconstructed from source at runtime and are not needed in the cache.
    cache_data = {
        "registration_cache": parser._registration_cache,
    }
```
</issue_to_address>

### Comment 2
<location> `src/codeweaver/__init__.py:54-59` </location>
<code_context>
                    git_describe = subprocess.run(
                        [git, "describe", "--tags", "--always", "--dirty"],
                        capture_output=True,
                        text=True,
                        check=False,
                    )
</code_context>

<issue_to_address>
**security (python.lang.security.audit.dangerous-subprocess-use-audit):** Detected subprocess function 'run' without a static string. If this data can be controlled by a malicious actor, it may be an instance of command injection. Audit the use of this call to ensure it is not controllable by an external resource. You may consider using 'shlex.escape()'.

*Source: opengrep*
</issue_to_address>

### Comment 3
<location> `src/codeweaver/semantic/node_type_parser.py:466-469` </location>
<code_context>
    def _load_file(self, language: SemanticSearchLanguage) -> list[dict[str, Any]] | None:
        """Load a single node types file for a specific language."""
        if language == SemanticSearchLanguage.JSX:
            language = SemanticSearchLanguage.JAVASCRIPT

        # If using package resources, load directly
        if self.directory is None:
            data_dir = files("codeweaver.data") / "node_types"
            filename = f"{language.value}-node-types.json"
            resource = data_dir / filename
            if resource.is_file():
                return from_json(resource.read_bytes())
            return None

        # Otherwise use file path
        file_path = next(
            (
                file
                for file in self.files
                if SemanticSearchLanguage.from_string(file.stem.replace("-node-types", ""))
                == language
            ),
            None,
        )
        if file_path and file_path.exists():
            return from_json(file_path.read_bytes())
        return None

</code_context>

<issue_to_address>
**suggestion (code-quality):** We've found these issues:

- Lift code into else after jump in control flow ([`reintroduce-else`](https://docs.sourcery.ai/Reference/Default-Rules/refactorings/reintroduce-else/))
- Replace if statement with if expression ([`assign-if-exp`](https://docs.sourcery.ai/Reference/Default-Rules/refactorings/assign-if-exp/))

```suggestion
            return from_json(resource.read_bytes()) if resource.is_file() else None
```
</issue_to_address>