Gossiphs

Gossiphs is a zero-configuration, high-performance general code file relationship analysis tool that supports multiple programming languages. It is based on tree-sitter and git analysis, provides support for Python SDK and MCP protocol, and is convenient for integration with AI.

Developer tools Artificial intelligence chatbots #Code analysis #Relationship graph #AI integration #Multi-language .Rust

rating : 2.5 points

downloads : 73

update time : 2025-04-29

What is Gossiphs?

Gossiphs is a tool that automatically generates a code file relationship graph by analyzing code commit history and variable declaration reference relationships. It supports multiple programming languages and can be used without additional configuration.

How to use Gossiphs?

It can be quickly integrated into your project through a simple Python SDK or MCP protocol, supporting network relationship graph export and code reference query functions.

Use cases

Scenarios such as code impact analysis, project understanding, code navigation enhancement, and context building for AI programming assistants.

Main features

Multi-language supportSupports 8 mainstream programming languages such as Rust, Python, and TypeScript.

Zero configurationNo additional configuration is required, and it can be used out of the box.

MCP integrationSupports the Model Context Protocol and can be seamlessly integrated with AI models.

Commit history analysisUtilizes Git commit history to optimize code relationship analysis.

Advantages and limitations

Advantages

Most code repositories can be analyzed without complex configuration.

The cost of extending language support is low.

Commit history analysis improves relationship accuracy.

Multiple integration methods such as Python SDK and MCP protocol are provided.

Limitations

Static analysis cannot completely replace the accuracy of LSP.

Analysis of complex scenarios such as dynamic binding is limited.

Adding support for new languages requires adding rule files.

How to use

Installation

Install the Python package via pip.

Basic usage

Create an analysis graph and obtain file relationships.

Export the relationship graph

Export the analysis results as a network graph.

Usage examples

Code impact analysisAnalyze other files that may be affected by modifying a certain file.

Project understandingQuickly understand the file organization structure of a new project.

Frequently asked questions

What's the difference between Gossiphs and LSP?

How to add support for a new language?

How accurate are the analysis results?

Related resources

GitHub repository

Project source code and latest updates.

Tree-Sitter

The syntax analysis framework used.

MCP protocol description

Detailed documentation of the Model Context Protocol.

🚀 Gossip Chatty Project Documentation

Gossip Chatty is a project dedicated to building a relationship graph between files in a code repository. It extracts import and export information between files and optimizes these relationships by combining commit history to establish a symbol graph that connects definition and reference nodes.

🚀 Quick Start

Supported Languages

Currently, the project supports the following languages:

Property	Details
Go	Supported
Rust	Supported
Python	Supported
JavaScript	Supported
TypeScript	Supported
Java	Not Supported
C#	Not Supported

Core Components

Rule Engine: Defines which symbols need to be imported or exported in different languages.
Extractor: Responsible for extracting symbol information from code files.
Graph Builder: Converts the extracted symbol information into a directed graph, where nodes represent symbols and edges represent dependency relationships.

Working Principle

Gossip Chatty builds a code dependency graph through the following steps:

Extract Imports and Exports: Identify import and export symbols in each file.
Establish Connections: Connect relevant symbol nodes according to rules.
Optimize Edges Using Commit History: Adjust and optimize the relationships between nodes by analyzing commit records.

Unlike Stack-Graphs, Gossip Chatty omits complex scope analysis and instead uses commit history to optimize edges. This approach significantly reduces the complexity of writing rules, as rules only need to specify the types of symbols that each file should export or import.

Precision Considerations

Static analysis has its limitations, such as the inability to handle dynamic binding issues. Therefore, Gossip Chatty cannot achieve the same level of precision as LSP/LSIF, but in most practical application scenarios, this level of precision is sufficient.

Repository Name	Gossiphs Coverage Relative to LSP Edges
https://github.com/go-gorm/gorm	442/499 = 88.5%
https://github.com/gin-gonic/gin	238/252 = 94.4%

Contribution Guidelines

The project is currently in a very early experimental stage. If you are interested, please leave your ideas in the issues. In the short term, we hope to build better support for more languages.

You need to: