code-knowledge-graph

Files (1)

• SKILL.md

SKILL.md (first lines)

---
name: code-knowledge-graph
description: "Codebase'i knowledge graph olarak analiz et. Dependency, call graph, hotspot analizi."
allowed-tools: [Bash, Read, Glob, Grep]
keywords: [dependency graph, code graph, knowledge graph, codebase analysis, architecture analysis, circular dependency, hotspot, orphan, call graph, import graph]
---

# Code Knowledge Graph - Codebase Graph Analysis

Codebase'i knowledge graph olarak modeller. Dosya, modul, fonksiyon ve class'lar node; import, call, inheritance ve composition iliskileri edge olur. Sonuc: Mermaid diagram + JSON graph data.

## Neden Knowledge Graph?

Kod text degil, **graph**'tir. Her dosya diger dosyalara baglidir. Bu baglantilari anlamadan:
- Refactoring yaparken neyi kiracagini bilemezsin
- Dead code'u guvenle silemezsin
- Yeni feature'in nereye oturacagini gormezsin
- Circular dependency'lerin kokunu bulamazsin

Knowledge graph tum bu iliskileri gorsellestirir ve olculebilir yapar.

## Kullanim

```
/code-knowledge-graph [hedef-dizin] [--focus module] [--depth N] [--format mermaid|json|both]
```

### Ornekler

```bash
# Tum codebase analizi
/code-knowledge-graph src/

# Belirli module odaklan
/code-knowledge-graph src/ --focus auth

# Sadece circular dependency kontrolu
/code-knowledge-graph src/ --focus circular

# Hotspot analizi
/code-knowledge-graph src/ --focus hotspots

# Orphan/dead code tespiti
/code-knowledge-graph src/ --focus orphans
```

## Graph Olusturma Adimlari

### Adim 1: Node Discovery

```bash
# Dosya agaci
tldr tree ${PATH:-src/} --ext .py

# Kod yapisi: fonksiyonlar, class'lar, export'lar
tldr structure ${PATH:-src/} --lang python
```

Her dosya, class, fonksiyon ve export bir **node** olur.

### Adim 2: Edge Extraction

```bash
# Dosyanin import'lari (outgoing edges)
tldr imports ${FILE}

# Modulu kim import ediyor? (incoming edges)
tldr importers ${MODULE} ${PATH:-src/}

# Cross-file call graph
tldr calls ${PATH:-src/}
```

Her import ve fonksiyon cagrisi bir **directed edge** olur.

### Adim 3: Layer Detection

```bash
# Architectural layer analizi
tldr arch ${PATH:-src/}
```

Node'lar 3 katmana ayrilir:

| Katman | Tanim | Ornekler |
|--------|-------|---------|
| Entry | Disaridan cagirilan, ici cagirmayan | routes, cli, main, handlers |
| Middle | Hem cagrilan hem cagirir | services, business logic |
| Leaf | Cagirilan ama baskasini cagirmayan | utils, helpers, constants |

### Adim 4: Impact Analysis

```bash
# Bu fonksiyona kim bagimli?
tldr impact ${FUNCTION} ${PATH:-src/} --depth 3

# Dead code: hicbir yerden cagrilmayan fonksiyonlar
tldr dead ${PATH:-src/}
```

### Adim 5: codebase-memory MCP Entegrasyonu

codebase-memory MCP kuruluysa, persistent graph sorgusu yap:

```
mcp: index_status       -> Repo index durumu
mcp: index_repository   -> Repo'yu indexle (yoksa)
mcp: query_graph        -> Graph sorgusu (iliskiler)
mcp: search_graph       -> Pattern arama
mcp: get_architecture   -> Mimari genel bakis
mcp: trace_call_path    -> Fonksiyonlar arasi cagri yolu
```

MCP, session'lar arasi kalici graph verisi saglar. tldr ise anlik taze analiz verir. Ikisini birlikte kullan.

## Dependency Analysis Pattern'leri

### Direct Dependencies
A dogrudan B'yi import ediyor:
```

From vibeeval/vibecosystem, MIT.

More from vibeeval/vibecosystem