/dotnet-techne-cross-repo-impact

name: dotnet-techne-cross-repo-impact
description: "Use when reviewing a .NET pull request for breaking changes that may affect other microservice repositories. Detects cross-repo API, DTO, endpoint, EF entity, and NuGet-package breaks, and checks whether a compatible downstream PR already exists. Keywords: cross-repo impact, breaking change, microservice compatibility, downstream break, compatible PR, blast radius review, api compatibility, contract break, dto shape change, endpoint break."
disable-model-invocation: false
user-invocable: true
license: MIT
compatibility: Requires Synopsis v1.6.0+ (from dotnet-techne-synopsis skill) with either its MCP daemon or CLI accessible. Requires git and a code-host CLI (gh for GitHub, glab for GitLab) for compatible-PR search. Works with any AI agent that supports the Agent Skills specification.
metadata:
  author: Metalnib
  version: "1.0.0"
  trigger_keywords:
    - cross-repo impact
    - breaking change review
    - microservice compatibility
    - downstream break
    - compatible PR
    - blast radius review
    - api compatibility
    - contract break
    - dto shape change
    - endpoint break
    - shared library bump

.NET Cross-Repo Impact Analysis

Procedural recipe for reviewing a .NET pull request against a multi-repo microservice workspace: detect breaking changes, trace their blast radius across repo boundaries, check for a compatible downstream PR, and render a structured `cross-repo-impact.md` report.

This skill is **procedural only**. It does not describe agent identity, default stance, or severity philosophy — those belong in the consuming agent's system prompt. This skill tells the agent *how* to run the analysis when invoked.

Requirements

• **Synopsis v1.6.0+** binary available, either:
• as a long-running MCP daemon (preferred — fastest, combined multi-repo

graph kept warm), or

• as a CLI invoked per-run (one-shot mode, no daemon required).

Use the companion `dotnet-techne-synopsis` skill to auto-download and detect the binary.

• **git** on the PATH for diff inspection.
• A code-host CLI on the PATH for compatible-PR search:
• `gh` for GitHub (authenticated, repo read).
• `glab` for GitLab (authenticated, MR read).
• Others acceptable if the agent's harness provides an equivalent

`searchOpenPrs` tool.

• Read access to a **workspace root** that contains the PR repo AND every

other repo in the fleet as peer directories (Synopsis discovers repos by `.git` markers under the root).

When to use this skill

Trigger this skill when a PR diff touches any of:

• Public types, methods, records, or interfaces in an assembly referenced

by other projects.

• ASP.NET controllers, minimal-API endpoints, route constants, or HTTP

verb attributes.

• EF Core entity classes, `DbContext` overrides, `OnModelCreating`

configurations, `ToTable` / `HasColumnName` calls, or migration files.

• DTO classes or records carrying `[JsonPropertyName]`, `[DataMember]`,

`[JsonConverter]`, or used as `HttpClient` request/response bodies.

• `PackageReference` elements in `.csproj` or `Directory.Packages.props`

where the package is also referenced by other repos.

• `appsettings.json` keys that appear as `ConfigurationKey` nodes in the

Synopsis graph.

If the diff is pure internal refactor (no public surface change, no cross-repo edges touched), skip this skill and run standard review skills only.

Operating modes

Pick the mode based on what is available:

Mode A — Daemon mode (preferred)

Used when a long-running `synopsis mcp` daemon is already serving a combined multi-repo graph (typical deployment for an autonomous review agent).

• Call MCP tools on the already-running daemon.
• Ask the daemon to re-index only the PR repo (`reindex_repository`) at

the head SHA before analysis; other repos stay warm.

• Fastest: typical review in a few seconds of graph work plus the LLM

turns.

Mode B — One-shot mode

Used when Synopsis is not running as a daemon (Claude Code user running this skill manually, CI one-shot, etc.).

• Scan the workspace once with `synopsis scan` to produce

`head.graph.json`.

• Scan the base revision (checkout base ref → `synopsis scan` →

`base.graph.json`).

• Run `synopsis breaking-diff base.graph.json head.graph.json --json` to

get classified breaking changes.

• Query the head graph for blast radius via `synopsis query symbol --fqn

<name> --blast-radius --json`.

Both modes produce the same findings; the skill text below uses MCP tool names and notes CLI equivalents where relevant.

Procedure

1. Resolve the workspace and PR

• Determine the **workspace root** (the directory containing all

microservice repo checkouts). The agent's harness should provide it; if not, infer from the parent of the PR repo and verify at least two sibling `.git` directories exist.

• Identify the PR repo, base ref, head SHA, and the list of changed files

via `git diff --name-only <base>...<head>`.

2. Ensure Synopsis sees the head revision

**Mode A:** call `reindex_repository { path: <pr-repo-abs-path>, ref: <head-sha> }`. Wait for response. Inspect returned delta stats to confirm at least one node changed.

**Mode B:** `synopsis scan <workspace-root> -o head.graph.json` at head SHA, then `git checkout <base-ref>`, then `synopsis scan <workspace-root> -o base.graph.json`, then restore head.

3. Compute classified breaking changes

**Mode A:** call `breaking_diff { before: <base.graph.json>, after: <head.graph.json> }`. (The daemon may cache `before` as part of its pre-PR baseline; confirm in the returned metadata.)

**Mode B:** `synopsis breaking-diff base.graph.json head.graph.json --json`.

The response is a typed list of changes. Each change has:

• `kind` — paired change kinds (`ApiSignatureChange`, `EndpointRouteChange`,

`EndpointVerbChange`, `TableRename`, `NugetVersionBump`), removal kinds (`ApiRemoved`, `EndpointRemoved`, `TableRemoved`, `PackageRemoved`)