How to Perform Type Checking on Specific OpenLogi Crates

Run cargo check -p <crate-name> from the repository root to type-check any individual OpenLogi crate without producing binaries, optionally followed by cargo clippy -p <crate-name> --all-targets -D warnings to enforce lint-level type safety.

OpenLogi is a multi-crate Rust workspace where each crate encapsulates a distinct responsibility such as core types, HID++ protocol handling, or desktop UI. To validate individual crate integrity without building the entire workspace, you can target specific crates with focused type checking commands that verify public APIs and internal implementations.

Selecting the Target Crate for Type Checking

OpenLogi organizes functionality into well-defined crates under the crates/ directory. Before running type checks, identify the specific crate you need to validate by locating its Cargo.toml:

• openlogi-core — Found at crates/openlogi-core/Cargo.toml, contains pure types, configuration structs, and locale handling.
• openlogi-agent — Located at crates/openlogi-agent/Cargo.toml, handles background agent logic, device I/O, and hook runtime.
• openlogi-desktop — Defined in crates/openlogi-desktop/Cargo.toml, implements the GPUI desktop client.
• openlogi-hidpp — Located at crates/openlogi-hidpp/Cargo.toml, provides the vendored HID++ protocol implementation.
• openlogi-permissions — Found at crates/openlogi-permissions/Cargo.toml, manages permission queries with platform-specific implementations in src/macos.rs and src/linux.rs.

Performing Type Checks on Individual Crates

Once you have identified the target crate, use the following commands to verify type correctness. These operations respect the workspace's feature flags and dependency resolution as configured in the root Cargo.toml.

Fast Validation with cargo check

The cargo check -p <crate> command performs the fastest type verification by compiling the crate and its dependencies without producing binaries or performing code generation. This catches type errors, missing trait implementations, and signature mismatches immediately.

cargo check -p openlogi-core

According to the OpenLogi source code, this command validates public API definitions in crates/openlogi-core/src/lib.rs, configuration structs in crates/openlogi-core/src/config.rs, and device model types in crates/openlogi-core/src/device.rs.

Enforcing Type Safety with Clippy

To ensure adherence to the repository's strict lint policy defined in the pre-push gate (docs/DEVELOPMENT.md), run Clippy with warnings treated as errors:

cargo clippy -p openlogi-core --all-targets -D warnings

This validates the same code paths as cargo check while enforcing additional lint-level type safety constraints across all targets, including binaries and tests.

Validating Test Code

If the crate contains unit tests (such as crates/openlogi-permissions/src/tests.rs), you must type-check the test code separately:

cargo test -p openlogi-permissions

This command compiles and executes tests, ensuring that test implementations in src/tests.rs and integration test files type-check correctly against the crate's public API.

Full Binary Validation

For crates producing binaries like openlogi-agent or openlogi-desktop, perform a full build to type-check the final artifact including linking:

cargo build -p openlogi-agent --release

This validates the binary entry point in crates/openlogi-agent/src/main.rs, the IPC server implementation in crates/openlogi-agent/src/server.rs, and watcher traits in crates/openlogi-agent/src/watchers/mod.rs.

Complete Type-Checking Workflow Example

Follow this sequence to thoroughly type-check a specific crate while respecting workspace conventions described in Developing OpenLogi:

# Navigate to the repository root

cd /path/to/OpenLogi

# 1. Fast type-check for core types

cargo check -p openlogi-core

# 2. Enforce lint policy with warnings as errors

cargo clippy -p openlogi-core --all-targets -D warnings

# 3. Validate test code compilation and execution

cargo test -p openlogi-core

Repeat this sequence for any crate (openlogi-agent, openlogi-desktop, openlogi-hidpp, etc.) by substituting the package name.

Understanding the Type-Checking Architecture

The workspace's Cargo configuration ensures that each crate's dependencies are resolved correctly through the shared workspace root. When you run cargo check, the compiler performs the same type inference as a full compilation but stops before code generation, providing immediate feedback on type correctness without linking overhead.

Key source files that define the types being validated include:

• openlogi-core: src/lib.rs (public API), src/config.rs (configuration), src/device.rs (device models)
• openlogi-agent: src/main.rs (binary entry), src/server.rs (IPC server), src/watchers/mod.rs (watcher traits)
• openlogi-desktop: src/main.rs (GPUI entry), src/services/i18n.rs (locale handling), src/windows/settings.rs (Windows UI settings)
• openlogi-hidpp: src/lib.rs (protocol implementation)
• openlogi-permissions: src/lib.rs (permission queries), src/macos.rs, src/linux.rs (platform-specific logic)

All commands support feature flag overrides using --features <feature> or --no-default-features to test conditional compilation paths.

Summary

• Use cargo check -p <crate> for rapid type verification without binary generation.
• Run cargo clippy -p <crate> --all-targets -D warnings to enforce the repository's zero-warnings policy.
• Execute cargo test -p <crate> to validate that test code compiles and passes.
• Reference crates/<crate-name>/Cargo.toml to identify package names and dependencies.
• Modify feature flags with --features or --no-default-features when checking conditional code paths.

Frequently Asked Questions

What is the fastest way to type-check a single OpenLogi crate?

cargo check -p <crate-name> is the fastest method. It compiles the crate and its dependencies but stops before code generation and linking, immediately surfacing type errors, missing traits, or signature mismatches without the overhead of producing binaries.

How do I handle feature flags when type-checking specific crates?

Append --features <feature-name> to enable specific features or use --no-default-features to disable them. For example: cargo check -p openlogi-core --features advanced-logging. This ensures your type-checking accounts for conditional compilation blocks gated by feature flags.

Can I type-check all OpenLogi crates at once?

Yes, running cargo check or cargo clippy from the repository root without the -p flag validates the entire workspace. However, targeting specific crates with -p significantly reduces iteration time when working on isolated components.

Why does type checking fail when the full build succeeds?

Type checking with cargo check validates all code paths including those that might be optimized away during release builds. If type checking fails while cargo build --release succeeds, you may have dead code with type errors or conditional compilation blocks that are excluded in release mode but included during check. Ensure all feature combinations compile correctly using --all-features or specific --features flags.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}