GitHub - zachsaw/graphify-csharp: Give your LLM agents the power of JetBrains Rider IDE! Supports C# 15 Syntax! · GitHub

Skip to content

Navigation MenuSign inAppearance settingsPlatformAI CODE CREATIONGitHub CopilotWrite better code with AIGitHub Copilot appDirect agents from issue to mergeMCP RegistryIntegrate external toolsDEVELOPER WORKFLOWSActionsAutomate any workflowCodespacesInstant dev environmentsIssuesPlan and track workCode ReviewManage code changesCode QualityEnforce quality at mergeAPPLICATION SECURITYGitHub Advanced SecurityFind and fix vulnerabilitiesCode securitySecure your code as you buildSecret protectionStop leaks before they startEXPLOREWhy GitHubDocumentationBlogChangelogMarketplaceView all featuresSolutionsBY COMPANY SIZEEnterprisesSmall and medium teamsStartupsNonprofitsBY USE CASEApp ModernizationDevSecOpsDevOpsCI/CDView all use casesBY INDUSTRYHealthcareFinancial servicesManufacturingGovernmentView all industriesView all solutionsResourcesEXPLORE BY TOPICAISoftware DevelopmentDevOpsSecurityView all topicsEXPLORE BY TYPECustomer storiesEvents & webinarsEbooks & reportsBusiness insightsGitHub SkillsSUPPORT & SERVICESDocumentationCustomer supportCommunity forumTrust centerPartnersView all resourcesOpen SourceCOMMUNITYGitHub SponsorsFund open source developersPROGRAMSSecurity LabMaintainer CommunityGitHub StarsArchive ProgramREPOSITORIESTopicsTrendingCollectionsEnterpriseENTERPRISE SOLUTIONSEnterprise platformAI-powered developer platformAVAILABLE ADD-ONSGitHub Advanced SecurityEnterprise-grade security featuresCopilot for BusinessEnterprise-grade AI featuresPremium SupportEnterprise-grade 24/7 supportPricingSearch/Sign inSign upAppearance settings

You signed in with another tab or window. Reload to refresh your session.
You signed out in another tab or window. Reload to refresh your session.
You switched accounts on another tab or window. Reload to refresh your session.

Dismiss alert

zachsaw

/

graphify-csharp

Public

Notifications
You must be signed in to change notification settings

Fork
0

Star
2

Code

Issues
0

Pull requests
0

Actions

Projects

Security and quality
0

Insights

Additional navigation options

Code

Issues

Pull requests

Actions

Projects

Security and quality

Insights

mainBranchesTagsGo to fileCodeOpen more actions menuLatest commit History52 Commits52 CommitsFolders and filesNameNameLast commit messageLast commit date.agents/skills.agents/skills  .github/workflows.github/workflows  docsdocs  scriptsscripts  srcsrc  teststests  .gitignore.gitignore  CHANGELOG.mdCHANGELOG.md  Graphify.CSharp.slnGraphify.CSharp.sln  LICENSELICENSE  README.mdREADME.md  View all filesRepository files navigationREADMEMIT licenseMore itemsgraphify-csharp 🚀

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

graphify-csharp is a free, headless Roslyn/MSBuild indexer that turns C#
source into deterministic, queryable semantic evidence: compiler-resolved
callers, references, implementations, inheritance, and overrides—even across
overloads, generics, and projects.
Think of it as the semantic-navigation slice of Rider/ReSharper, exported for
Codex, Claude Code, and other coding agents.
MIT licensed · No IDE · No compiled project DLL required · No database · Graphify optional
Stop making your agent guess
Suppose you ask:

Which methods are used only by tests?

A text search can find matching spellings. It cannot reliably tell which
overload was bound, which project the caller belongs to, or whether an
interface implementation is the symbol you meant.
Graphify C# loads the project through MSBuild and asks Roslyn what every symbol
actually means. It emits stable identities and directed relationships that an
agent can inspect instead of infer:

Without semantic indexing
With Graphify C#

Matching names look like usages
Roslyn resolves the exact declaration

Overloads and generics are ambiguous
Bound signatures and project/TFM identity are retained

Test-only usage requires manual inspection
Every caller carries project, namespace, and source location

Type relationships are reconstructed from text
inherits, implements, and overrides are explicit edges

For example, this repository contains an internal
DeclarationCatalogBuilder.ForTesting(...) method. From the extracted graph,
an agent can see one compiler-resolved incoming call:
Graphify.CSharp.Roslyn.DeclarationCatalogBuilder.ForTesting(...)
└── called by Graphify.CSharp.Tests.Roslyn.CSharp14FeatureTests
at tests/Graphify.CSharp.Tests/Roslyn/CSharp14FeatureTests.cs:143

That is semantic evidence, not a text-match count. A consumer can classify the
caller by project or namespace convention and report the method as test-only
for human review.
Quick start
1. Install
dotnet tool install --global Graphify.CSharp --framework net10.0
2. Index your codebase
graphify-csharp \
--input ./src/MyProduct.sln \
--root . \
--configuration Release \
--output ./graphify-out/csharp.json
The result is one complete JSON document containing nodes, edges, and
hyperedges. It can be read directly by an agent, queried with jq, consumed
from your own code, or passed to Graphify.
Supported inputs are .sln, .slnx, .csproj, and SDK file-based .cs apps.
The repository's SDKs, packages, and MSBuild inputs must be available locally.
3. Teach your agent to use it
The included graphify-csharp skill
teaches an agent when to refresh the index, how to follow semantic edges, and
where static analysis stops.
Install it in a Codex-compatible project:
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 Claude Code, use .claude/skills/graphify-csharp/SKILL.md instead. Reload
an agent session after installing or updating the skill.
If you do not use skills, add this to your project instructions:

For C# structure and usage questions, refresh
graphify-out/csharp.json with graphify-csharp before answering. Identify
declarations by symbol_key and inspect incoming calls and references
edges. Treat zero inbound edges as observed static evidence, not proof of
runtime unreachability.

Now ask your agent:

What calls this exact overload or constructor?
Which source declarations reference this field, property, event, or type?
Which classes implement this interface?
Which members override this virtual or interface member?
Which declarations have zero observed inbound references?
Which methods are referenced only from test projects?

From IDE navigation to agent evidence

What a developer does in Rider
What an agent gets from Graphify C#

Find Usages
Directed, compiler-resolved calls and references edges

Jump to Implementation
implements edges to the exact interface contract

Navigate base and derived types
inherits and overrides edges

Disambiguate overloads and generics
Stable symbol identities with bound signature information

Inspect a large solution
Project, target-framework, source-location, and provenance metadata

Keep navigating while editing
Incremental indexing with an optional warm watcher

The extractor supplies the facts. Your agent or downstream consumer decides
what those facts mean: test-only usage, zero observed references, a deletion
candidate, or something requiring human review.
Where it fits
Graphify C# deliberately covers a focused layer:

Rider and ReSharper provide interactive navigation, inspections,
refactorings, and quick fixes for developers inside an IDE.
NDepend provides a broad, commercial architecture and code-quality suite
built around dependency analysis, metrics, rules, reports, baselines, and
visualizations.
Graphify C# provides source-level C# semantic evidence for coding agents,
headlessly and in an open format.

There is real overlap with NDepend around callers, dependencies, inheritance,
and dead-code investigation. The difference is the product boundary: Graphify
C# is not a free NDepend clone or an IDE replacement. It is a Roslyn-native
semantic index that other tools and agents can build on.
Use it with Graphify—or without it
Graphify C# is standalone. It does not invoke, load, or require Graphify.
Without Graphify, query the JSON with an agent, jq, C#, Python, or any other
consumer. For example, list every indexed method:
jq '.nodes[] | select(.properties.node_kind == "method")' \
graphify-out/csharp.json
With Graphify, refresh the C# evidence and use its higher-level query, path,
explanation, clustering, and export workflows:
graphify-csharp \
--input ./src/MyProduct.sln \
--root . \
--configuration Release \
--output ./graphify-out/csharp.json

graphify query "Which methods call the order service?" \
--graph ./graphify-out/csharp.json
Graphify remains the general graph workflow. graphify-csharp contributes the
C# layer where compiler binding matters.
What gets indexed
Source declarations

Namespaces, classes, structs, interfaces, records, enums, and delegates
Constructors, methods, operators, and local functions
Properties, indexers, fields, enum members, and events
Parameters, locals, type parameters, aliases, labels, and query range variables

Compiler-resolved relationships

Direct calls, constructor calls, method groups, and member access
Field, type, attribute, generic, typeof, and declaration-header references
inherits, implements, and overrides
Compiler-selected operators, conversions, deconstruction, foreach,
await, using, patterns, ranges, and collection expressions
Invocation and constructor arguments bound to source formal parameters
Cross-project relationships with overload-aware, project/TFM-aware identity

Every edge points from the declaration where the relationship was observed to
the declaration Roslyn resolved. Source location and provenance are retained.
Unsupported semantic shapes are reported as diagnostics instead of silently
disappearing or crashing the entire extraction.
See Compatibility for the complete language and
compiler-feature matrix.
Keep the index warm
For repeated agent work, start a watcher:
graphify-csharp \
--input ./src/MyProduct.sln \
--root . \
--configuration Release \
--output ./graphify-out/csharp.json \
--watch
The watcher keeps the Roslyn workspace warm and prepares changed projects in
the background. A normal graphify-csharp invocation acts as an explicit
refresh barrier and returns only after a complete JSON snapshot is current.
If no matching watcher is running, the same command performs a one-shot
refresh. Use --rebuild to invalidate the incremental cache.
See Usage and
Incremental indexing for watcher ownership,
filtering, recovery, and cache behavior.
Runtime and language support
The package contains two tool assets:

Tool asset
Runtime
Compiler surface

net10.0
.NET 10
Roslyn 5.9 / C# 14

net11.0
.NET 11
.NET 11 SDK Roslyn / C# 15 preview

Install or update the package with dotnet tool ... --framework to select the
tool runtime and Roslyn asset:
dotnet tool update --global Graphify.CSharp --framework net11.0
This is separate from the optional --target-framework argument, which chooses
one analyzed compilation when an input project targets multiple frameworks.
Single-target projects do not need --target-framework.
Static-analysis boundary
Graphify C# reports what Roslyn can observe statically. Reflection, dependency
injection, native callbacks, dynamic invocation, and code absent from the
loaded compilation may create runtime relationships that are not represented
as direct edges.
Consequently:

zero inbound references means zero observed static references;
a test-only result depends on your project or namespace classification; and
every deletion candidate still requires judgment.

The tool exposes this boundary instead of pretending static evidence is a
runtime reachability proof.
Development
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

License
MIT. See LICENSE.
AboutGive your LLM agents the power of JetBrains Rider IDE! Supports C# 15 Syntax!ResourcesReadmeMIT licenseActivityStars2 starsWatchers0 watchingForks0 forksReport repositoryReleasesPackagesContributorsLanguages

Footer

© 2026 GitHub, Inc.

Footer navigation

Terms

Privacy

Security

Status

Community

Docs

Contact

Manage cookies

Do not share my personal information

You can’t perform that action at this time.

Graphify Csharp is a free, headless indexer built upon Roslyn and MSBuild that transforms C# source code into deterministic and queryable semantic evidence. Its primary function is to derive compiler-resolved information, including method callers, references, implementations, inheritance relationships, and overrides, even when dealing with complex scenarios involving overloads, generics, and multiple projects. It is designed to serve as the semantic-navigation layer for coding agents, providing them with verifiable structure rather than relying on ambiguous text matching.

The core innovation of Graphify Csharp lies in moving beyond superficial text analysis to capture actual compiler-resolved relationships. Unlike methods that might suggest a textual similarity between names, Graphify Csharp establishes stable identities and directed relationships (edges) directly derived from the Roslyn compiler analysis. For example, it resolves ambiguities inherent in overloads and generics by retaining bound signature and project/Team Foundation Member (TFM) identities, ensuring that an agent receives accurate structural data rather than inferred possibilities. This allows agents to accurately determine, for instance, which specific overload was called or which project an interface implementation resides in.

This semantic evidence allows coding agents to perform sophisticated reasoning. They can inspect the derived graph to answer complex questions about the codebase, such as identifying methods used exclusively by test projects, tracing all source declarations referencing a specific field, or identifying methods that override specific virtual members. This capability transforms what would otherwise require extensive human inspection into verifiable static evidence.

The process involves indexing the codebase, which can be initiated via a command-line interface to produce a comprehensive JSON document containing nodes, edges, and hyperedges. This output can be consumed directly by agents, queried using tools like jq, or used by custom applications. Furthermore, the repository includes an integrated skill designed to teach agents how to utilize this graph, instructing them on how to follow semantic edges and where static analysis concludes.

Graphify Csharp operates distinctly from tools like IDE navigation, such as those found in Rider or ReSharper, and broader dependency analysis suites like NDepend. It occupies a focused niche by providing fine-grained, source-level C# semantic evidence specifically tailored for coding agents. It is not an IDE replacement or a direct clone of dependency analysis tools, but rather a Roslyn-native semantic index that others can build upon.

The indexing captures a vast amount of detail, including source declarations for namespaces, classes, interfaces, and members, as well as all compiler-resolved relationships between them, including direct calls, member access, inheritance hierarchies, and operator resolutions. Crucially, the system retains source location and provenance for every relationship observed, ensuring that the derived facts are traceable back to the source code. For performance and repeated agent work, Graphify Csharp supports incremental indexing through a watcher mechanism, which keeps the Roslyn workspace warm and prepares background updates.

The system supports multiple runtime environments, offering support for .NET 10.0 and preview support for .NET 11.0, which incorporates Roslyn and C# 15. The tool explicitly defines the boundary of static analysis, noting that runtime relationships, such as those involving reflection or dynamic invocation, are not directly represented as static edges, thereby clearly delineating the scope of what can be proven statically versus what requires runtime judgment.