Index C# codebases for compiler-accurate usage analysis

graphify-csharp 🚀

Give coding agents compiler-accurate Find Usages for C#.

graphify-csharp is a free, headless Roslyn/MSBuild indexer for coding agents. It turns a C# solution or project into deterministic semantic evidence: exact callers, references, implementations, inheritance, overrides, and argument bindings-even across overloads, generics, and project boundaries.

Think of the semantic-navigation part of Rider or ReSharper, exported for Codex, Claude Code, Cursor, and other tools that need to reason about a C# codebase without guessing from filenames or text matches.

MIT licensed · No IDE · No prebuilt project DLL as input · No database · Graphify optional

The problem

Ask an agent:

Which methods are used only by tests?

Text search can find a spelling. It cannot reliably tell whether a call binds to the int or string overload, whether an interface member dispatches to a derived implementation, or which project a caller belongs to. That is how plausible-looking dead-code reports become unsafe.

Graphify C# loads the evaluated project with MSBuild and asks Roslyn which symbols and relationships the compiler resolved:

The tool reports the evidence. Your agent can then classify callers using the repository's naming convention, such as projects or namespaces containing Tests, and decide what deserves human review.

Quick start

1. Install the global tool

dotnet tool install --global Graphify.CSharp --framework net10.0

Use the net11.0 asset for C# 15 preview input when the .NET 11 SDK is installed:

dotnet tool install --global Graphify.CSharp --framework net11.0

If the tool is already installed, use dotnet tool update with the same --framework instead.

2. Export a complete graph

From a repository containing one solution or project, the shortest form is:

graphify-csharp

It discovers one .sln/.slnx or, when no solution exists, one .csproj directly in the current directory and writes:

./graphify-out/csharp.json

For a repository whose solution is under src, be explicit:

graphify-csharp export \
  --input ./src/MyProduct.sln \
  --root . \
  --configuration Release \
  --output ./graphify-out/csharp.json

The output is one complete JSON document with nodes, edges, and hyperedges. It can be inspected by an agent, queried with jq, consumed by your own program, or passed to the optional Graphify executable.

Upgrading from v0.1? See the concise v0.2 migration guide for the watch/export --instance command split, output changes, and path semantics.

3. Give your agent the usage instructions

The repository includes a copyable consumer skill. It teaches an agent how to start a warm session, use exact symbol IDs, inspect callers and relationships, interpret static-analysis limits, and export JSON when needed. Installing the NuGet package installs the executable; it does not install a skill.

Project-local Codex setup:

mkdir -p .agents/skills/graphify-csharp
curl -fsSL \
  https://raw.githubusercontent.com/zachsaw/graphify-csharp/main/.agents/skills/graphify-csharp/SKILL.md \
  -o .agents/skills/graphify-csharp/SKILL.md

For a personal Codex installation, use ~/.codex/skills/graphify-csharp/. For Claude Code, use .claude/skills/graphify-csharp/ in a project or ~/.claude/skills/graphify-csharp/ for a personal installation. Reload the agent after installing or updating the file.

Without a skills system, put this in the repository's agent instructions:

For C# structure and usage questions, use the graphify-csharp CLI. Identify declarations by their exact symbol_key/node ID and inspect incoming calls, references, inherits, implements, and overrides relationships. Treat zero inbound edges as zero observed static references, not proof of runtime unreachability.

What an agent can ask

• What calls this exact overload or constructor?
• Which declarations reference this field, property, event, type, or enum member?
• Which classes inherit from this type or implement this interface?
• Which overrides satisfy this virtual or interface member?
• Which arguments bind to which formal parameters?
• Which declarations have zero observed inbound static references?
• Which callers originate from projects or namespaces named Tests?
• Which declarations are candidates for a test-only usage report?

The last two are analysis questions, not hard-coded classifications. The tool returns caller provenance; the agent applies the naming convention you choose and reports the scope and caveats.

Warm semantic navigation

For repeated agent work, keep a Roslyn workspace warm. watch is a foreground, output-free session; it does not write JSON. Run it in one terminal:

graphify-csharp watch

If discovery is ambiguous, specify the input and root:

graphify-csharp watch \
  --input ./src/MyProduct.sln \
  --root . \
  --configuration Release

The watcher prints a full session ID and resolved analysis context on stderr while it starts. In another terminal, use that ID (or a unique prefix):

graphify-csharp ps --json
graphify-csharp info <session-id> --json
graphify-csharp query symbols OrderService --instance <session-id> --kind class --json
graphify-csharp query callers --instance <session-id> --symbol <symbol-id> --json
graphify-csharp query usage-summary \
  --instance <session-id> \
  --kind method \
  --group-by project,namespace \
  --json

Use symbols first when a name has overloads. Then pass the exact returned symbol ID to signature, callers, usages, hierarchy, or arguments. Queries return bounded JSON pages with the evidence snapshot used to answer them. A live session is also useful for edits: queries, exports, and explicit refreshes wait for the session's startup/recovery barrier.

When the agent needs a complete graph, request it explicitly:

graphify-csharp export --instance <session-id>

This writes the default ./graphify-out/csharp.json under the calling terminal's current directory. Choose another destination with --output. The watcher does not publish a new JSON file merely because a source file changed; export is the explicit publication request.

Useful lifecycle commands:

graphify-csharp refresh --instance <session-id>
graphify-csharp refresh --instance <session-id> --rebuild
graphify-csharp diagnostics <session-id> --output ./graphify-out/diagnostics.json
graphify-csharp stop <session-id>

refresh updates trusted in-memory evidence without creating a graph file. --rebuild invalidates reusable contributions for that refresh. stop targets only the selected session; multiple sessions can run at once.

One-shot queries

You do not need a watcher or a JSON dump for a single question:

graphify-csharp query callers \
  --input ./src/MyProduct.sln \
  --root . \
  --configuration Release \
  --symbol '<exact-symbol-id>' \
  --json

Cold queries require explicit --input. They do not create a persistent session, output file, cursor, or snapshot. A selected --instance never falls back to cold analysis if that session is missing.

The JSON shape

The complete export is deliberately simple to consume. This is an abridged shape; IDs and symbol keys are generated from the actual Roslyn declarations:

{
  "nodes": [
    {
      "id": "cs_<stable-node-id>",
      "label": "OrderService.Submit(int)",
      "properties": {
        "node_kind": "method",
        "symbol_key": "csharp/v1|...",
        "project": "src/Orders/Orders.csproj",
        "target_framework": "net10.0"
      }
    }
  ],
  "edges": [
    {
      "source": "cs_<caller-node-id>",
      "target": "cs_<stable-node-id>",
      "relation": "calls",
      "source_file": "src/Orders/OrderController.cs"
    }
  ]
}

calls, references, inherits, implements, and overrides are compiler- resolved relationships. Locations identify where the relationship was observed. Invocation and constructor arguments can also be mapped to their source formal parameters.

Graphify is optional-and a separate tool

graphify-csharp does not invoke, load, or require the separate graphify executable. You can use the CLI and JSON directly with an agent, jq, C#, Python, or another consumer.

If you use Graphify as well, keep the roles separate:

1. graphify-csharp produces the C# semantic document or answers a C# query.
2. The separate graphify executable consumes that document for its own higher-level graph queries, paths, explanations, clustering, or exports.

graphify-csharp export \
  --input ./src/MyProduct.sln \
  --root . \
  --output ./graphify-out/csharp.json

graphify query "Which methods call the order service?" \
  --graph ./graphify-out/csharp.json

The optional Graphify skill teaches the graphify tool. The graphify-csharp skill in this repository teaches this CLI. Install both alongside one another only when you want both workflows; one does not install or silently invoke the other.

Runtime and language support

The package contains two global-tool assets:

The install-time --framework chooses which executable asset runs. The optional analysis-time --target-framework chooses one target framework when the analyzed project itself targets multiple frameworks. A single-target project normally needs no target selector.

Static-analysis boundary

This is compiler evidence, not a runtime reachability proof. Reflection, dependency injection, dynamic invocation, native callbacks, generated code outside the evaluated compilation, and external consumers can create runtime relationships that do not appear as direct static edges.

Therefore:

• zero inbound edges means zero observed static references in the selected scope;
• test-only usage depends on the project/namespace convention applied by the agent; and
• a deletion candidate still needs review of entry points, reflection, DI, source generators, public API consumers, and build/test behavior.

Unsupported or unrepresentable semantic shapes are reported as diagnostics where possible instead of crashing the entire extraction.

Development

To contribute to the indexer itself:

dotnet restore Graphify.CSharp.sln
dotnet build Graphify.CSharp.sln --configuration Release
dotnet test Graphify.CSharp.sln --configuration Release
dotnet pack src/Graphify.CSharp.Cli --configuration Release

More detail:

• Usage
• Compatibility
• Incremental indexing design
• Release and NuGet publishing