Managing Gradle Dependencies

Authoritative Dependency Intelligence & Maven Central Search

Audits project dependencies, performs high-resolution update checks, and discovers new libraries on Maven Central with powerful, integrated search tools.

Constitution

• ALWAYS use inspect_dependencies for querying project dependency information instead of raw Gradle tasks.
• ALWAYS provide absolute paths for projectRoot.
• ALWAYS use updatesOnly: true to quickly identify available library updates.
• ALWAYS use lookup_maven_versions to find exact GAV coordinates for new libraries.
• NEVER add a dependency to a project without verifying its authoritative version and existence on Maven Central.
• ALWAYS use the projectPath argument to target specific modules in multi-project builds.

Directives

• Identify authoritative paths: ALWAYS use the Gradle project path (e.g., :app) when querying dependencies.
• Inspect plugins and build scripts: Build script dependencies (like plugins) are automatically included in inspect_dependencies output under configurations prefixed with buildscript: (e.g. buildscript:classpath).
• Monitor for updates: ALWAYS use updatesOnly: true in inspect_dependencies to retrieve a flat, high-signal report of available library updates: group:artifact: current → latest with the project paths where each dep is used.

Configuration and source-set detail is intentionally omitted; use inspect_dependencies with a specific dependency filter if that detail is needed.

• Target dependencies surgically: Use the dependency parameter in inspect_dependencies to target a single library. It supports group:name:version:variant, group:name:version, group:name, or just group. This is significantly

faster than resolving the entire project graph.

• Efficient Transitive Isolation: When isolating a single library, filter the flattened list of resolved components using the dependency filter rather than traversing the dependency graph. This naturally and efficiently excludes

transitive dependencies that do not match the targeted filter.

• Discover libraries surgically: ALWAYS use lookup_maven_versions to check the version history of an existing artifact.
• Use gradle for diagnostics: For built-in tasks like dependencyInsight, ALWAYS use the gradle tool with captureTaskOutput.
• Audit full trees: ALWAYS use onlyDirect: false in inspect_dependencies when you need to visualize the complete transitive dependency graph.

When to Use

• Dependency Tree Auditing: When you need to visualize the full dependency graph for a specific project, configuration, or source set.
• Automated Update Detection: When performing maintenance and you want a concise report on available stable or pre-release updates.
• Precision Artifact Discovery: When looking for new libraries on Maven Central and you need to find exact GAV coordinates or explore an artifact's full version history.
• Version Conflict Resolution: When you need to identify why a specific version of a library is being resolved and look for compatible alternatives.
• Targeted Audit: When you only care about a specific library and want to bypass the cost of a full project resolution.

Workflows

1. Auditing Dependencies

• Identify the project module (e.g., :app).
• Call inspect_dependencies(projectPath=":app").
• Optionally filter by configuration (e.g., runtimeClasspath) or sourceSet (e.g., test).

2. Checking for Stable Updates

• Call inspect_dependencies(updatesOnly=true, stableOnly=true).
• Review the flat list of upgradeable dependencies. Each entry shows group:artifact: current → latest and the project paths where it is used.

3. Discovering New Libraries

• Use lookup_maven_versions(coordinates="group:artifact") to see all available versions for a specific library.

4. Targeted Dependency Inspection

• Identify the dependency you want to check (e.g., org.mongodb:mongodb-driver-sync).
• Call inspect_dependencies(dependency="org.mongodb:mongodb-driver-sync").
• The report will be focused ONLY on that library across all matched configurations.

Examples

List dependencies for a specific module

{
  "projectPath": ":app"
}
// Reasoning: Auditing the direct and transitive dependencies of the 'app' module to understand its runtime footprint.

Check for updates for a specific library

{
  "dependency": "org.jetbrains.kotlinx:kotlinx-coroutines-core",
  "updatesOnly": true
}
// Reasoning: Surgically checking if a specific library has available updates.

Check for stable updates across the project

{
  "updatesOnly": true,
  "stableOnly": true
}
// Reasoning: Performing a high-signal update audit that ignores unstable pre-release versions.

List all versions of a specific library

{
  "coordinates": "org.jetbrains.kotlinx:kotlinx-serialization-json"
}
// Reasoning: Retrieving the full version history of an artifact to identify the latest stable or specific version required.

Troubleshooting

• Dependency Not Found: Verify the projectPath using the projects task in the introspecting_gradle_projects skill.
• Update Not Showing: If a known update is missing, ensure stableOnly is set correctly and check if a versionFilter is active.
• [UPDATE CHECK SKIPPED]: This annotation means the dep was in scope for update checking but its resolution genuinely failed — it does NOT appear for dependencies intentionally excluded from the update-check scope (e.g., transitive deps

when onlyDirect=true, or deps excluded by a dependency filter).

• Maven Search No Results: Use broader search terms or verify the group:artifact format for version searches.
• Missing environment variables: Set invocationArguments: { envSource: "SHELL" } if Gradle cannot find expected env vars (e.g., JAVA_HOME).