Add Semantic Diff Understanding

[nirvik34]

Right now Gitbun mostly understands changes at a surface level by looking at filenames, folders, and raw diffs. That works fine for smaller commits, but it starts becoming inaccurate during larger refactors or structural code changes.

For example, if someone renames a function, extracts logic into another file, or changes an API signature, Gitbun currently just sees line changes instead of understanding what actually happened.

The goal of this issue is to make the analyzer more semantic-aware so generated commit messages become smarter during complex code changes.

A few examples of things that would be useful to detect:

• renamed functions/methods
• extracted or moved logic
• API/interface changes
• larger architectural refactors

This will probably require some form of AST-based analysis instead of relying only on raw git diffs.

Possible starting points:

• Tree-sitter
• ts-morph
• Babel AST
• TypeScript compiler APIs

The implementation does not need to support every language immediately. Even improving semantic understanding for TypeScript/JavaScript first would already be a huge improvement.

Try to keep performance in mind as well. The analyzer should still remain reasonably fast on larger repositories.

[sanrishi]

Just researched this and want to pick this up for tommorow's assignment, assign it over @nirvik34

[PiyushRai98]

Hi @nirvik34,

I’d like to work on this issue under GSSoC'26.

After reviewing the current analyzer pipeline (src/analyzer, summarizer.ts, typeClassifier.ts, and the diff-scanning flow), I believe a semantic-analysis layer would integrate well with the existing heuristic-based architecture.

My proposed approach is to introduce an AST-based semantic analysis module for TypeScript/JavaScript files, likely using ts-morph or the TypeScript Compiler API as the initial implementation layer. The first phase would focus on lightweight semantic event detection while keeping the analyzer performant and incremental.

Planned scope for the initial implementation:

• AST parsing for staged TS/JS files only
• semantic event extraction pipeline
• function/method rename detection
• basic API signature change detection
• integration with the existing summarizer and commit-generation flow
• unit tests for semantic diff classification

I also plan to structure the implementation in an extensible way so future detectors (logic extraction, moved code, architectural refactors, etc.) can be added without affecting the current analyzer pipeline.

Could you please assign this issue to me?

[nirvik34]

@PiyushRai98 Assigned the issue

[sanrishi]

@nirvik34 Why not me? i commented first right? Are you have doubt on my capabilities? already merged 3 Prs in two days
two advanced and one critical issues:
Advanced
Critical
Avanced

[nirvik34]

Hi @sanrishi,
Not at all, this decision wasn’t based on capability. I’ve already assigned you another issue because I saw your previous contributions and knew you could handle advanced tasks well.

For this specific issue, @PiyushRai98 shared a very detailed implementation plan around AST-based semantic analysis, integration points, and scalability of the analyzer pipeline, so I decided to proceed with that assignment.

[PiyushRai98]

@nirvik34 PR ready for review: #25 . Implements AST-based rename, signature, and interface change detection for TS/JS. All tests passing and review comments addressed.