Okuma süresi : 12 minutes

Codebaseniz büyüyor. Modüller arasındaki bağımlılıklar artıyor. Mimari dokümantasyon, yazılmadan önce güncelliğini yitiriyor. Ve Gradle build’inizin otomatik olarak gerçek kod yapısından güncel diyagramlar üretebileceğinizi hayal edin? Bu, Graphify + PlantUML Gradle Plugin işlem hattının tam olarak yaptığı şey:`graphify . --no-viz`Knowledge Graph’ı çıkarır`./gradlew generateKnowledgeGraphDiagram`onu PlantUML diagramlarına dönüştürür. Sıfır LLM, sıfır kılavuz, %100 determinist.

Sorun: diagramlar her zaman koddan geride kalıyor

Binlerce satırı aşan her proje bu sendromu yaşar:

  1. Projenin başında bir mimari diyagramı çizeriz.

  2. Kod gelişir, bağımlılıklar değişir

  3. Diyagram, dekoratif bir yalan hâline geliyor

  4. Kimse onu güncellemez çünkü zorlayıcıdır.

  5. Yeni gelenler ona dayanır ve hatalar yapar.

@startuml
skinparam backgroundColor #FEFEFE
skinparam ActivityBackgroundColor #FDEDEC
skinparam ActivityDiamondBackgroundColor #FFF3CD

start

:Oluşturulan mimari diyagram\n(manuellement, à la main);

:Kod gelişiyor\n(nouvelles classes, nouvelles dépendances);

:Eski diyagram\n(ne reflète plus le code);

if (Qui met à jour ?) then (Personne)
    :yanlış belge;
    note right: Yeni geliştiriciler\nonu temel alırlar... ve hatalar yaparlar
else (Quelqu'un)
    :Manuel güncelleme\n(2-3 heures de travail);
    note right: Zaten geçerli değil\nBir sonraki PRde
endif

stop

@enduml

Soru şema gerekir mi ? — herkes evet bilir. Soru :Onları güncel kim tutar?

Cevap: kimse. Otomatik olduğu zaman.

Çözüm : bir deterministik pipeline Knowledge Graph → PlantUML

Prinsip basittir : Diagramleri elle çizmek yerine, onlarıgerçek kod yapısından üretir.

@startuml
skinparam backgroundColor #FEFEFE
skinparam componentStyle rectangle

actor Développeur
component "Graphify\n(pip install graphifyy)" as Graphify
collections "graphify-out/graph.json\n(Knowledge Graph)" as KGJSON
component "PlantUML Gradle Plugin\n(generateKnowledgeGraphDiagram)" as Plugin
component "KnowledgeGraphParser" as Parser
component "KnowledgeGraphRenderer" as Renderer
component "PlantumlService\n(validation + rendu PNG)" as PS
collections "diagrams/knowledge-graph/\n(.puml + .png)" as Output

Développeur --> Graphify : grafikleştir . --no-viz
Graphify --> KGJSON : kaynak kodun yapısını çıkarır
Développeur --> Plugin : ./gradlew generateKnowledgeGraphDiagram
Plugin --> Parser : parse(graph.json)
Parser --> Plugin : KnowledgeGraph\n(noeuds + arêtes + communautés)
Plugin --> Renderer : render(graph, filters)
Renderer --> Plugin : code PlantUML\ndeterministik
Plugin --> PS : validateSyntax + generateImage
PS --> Output : .puml + .png

note bottom of Plugin
Boru hattı DÉTERMINISTE
Hiçbir çağrı LLM
Tekrarlanabilir sonuç
end note

@enduml

İki komut. Sadece.

# Étape 1 : extraire le Knowledge Graph
graphify . --no-viz

# Étape 2 : générer les diagrammes PlantUML
./gradlew generateKnowledgeGraphDiagram

Sonuç ? Dosyalar`.puml` et .png`içinde`diagrams/knowledge-graph/, Git’te versiyon kontrolü altında, kodla her zaman güncel.

Adım 1: Graphify’i yükleyin ve Knowledge Graph’i çıkarın

Kurulum

Graphify, kod tabanınızı analiz eden ve yapılandırılmış bir bilgi grafiği oluşturan bir Python aracıdır.

# Méthode recommandée
uv tool install graphifyy && graphify install --platform opencode

# Alternative avec pip
pip install graphifyy && graphify install --platform opencode

Istisnaları yapılandır

Dosya oluştur`.graphifyignore`proje kök dizininde, iş mantığının bir parçası olmayan dosyaları dışlamak için :

# Secrets — JAMAIS dans le graphe
*-context.yml
*.env

# Fichiers générés
build/
.gradle/

# Tests fonctionnels
src/functionalTest/

Knowledge Graph’ı çıkarma

graphify . --no-viz

bayrak`--no-viz`HTML üretimini atlar (Gradle pipeline’ında gereksiz). Sonuç bir dosya.`graphify-out/graph.json`içeren :

  • düğümlersınıflar, fonksiyonlar, dosyalar — tipi ve topluluğu ile

  • Kenarlardüğümler arasındaki ilişkiler (EXTRACTED koddan, INFERRED LLM tarafından)

  • topluluklarbağlı düğümlerin otomatik gruplamaları

Yapı örneği`graph.json`
{
  "nodes": [
    {"id": "0", "label": "LlmService", "file_type": "code", "community": 0},
    {"id": "1", "label": "ApiKeyPool", "file_type": "code", "community": 0},
    {"id": "2", "label": "PlantumlService", "file_type": "code", "community": 1}
  ],
  "links": [
    {"source": "1", "target": "0", "relation": "uses", "confidence": "EXTRACTED", "weight": 0.9},
    {"source": "0", "target": "2", "relation": "calls", "confidence": "INFERRED", "weight": 0.7}
  ]
}

Kaynak kod (.kt, .java) yerel olarak tree-sitter tarafından analiz edilir,çağrı olmadan LLM. Sadece belge dosyaları (.adoc, .md) bir LLM çağrısı semantik çıkarma için gerektirir. Dolayısıyla`--update`Kotlin kodunu tarama hemen hemen anıktır.

Adım 2: Gradle eklentisi, Knowledge Graph’ü PlantUML’e dönüştürür.

Pipeline mimarisi

Eklenti`com.cheroliv.plantuml`Bir görevi entegre eder`generateKnowledgeGraphDiagram`dönüştürür`graph.json`PlantUML diyagramlarında biçimindetamamen deterministik:

@startuml
skinparam backgroundColor #FEFEFE

participant "Gradle" as G
participant "GenerateKnowledgeGraphDiagramTask" as Task
participant "KnowledgeGraphParser" as Parser
participant "KnowledgeGraphRenderer" as Renderer
participant "PlantumlService" as PS

collections "graphify-out/graph.json" as JSON

G -> Task : yürütmek
Task -> JSON : Okuma
Task -> Parser : parse(graph.json)
Parser --> Task : KnowledgeGraph\n(noeuds + arêtes + communautés)
Task -> Renderer : render(graph, filters)
Renderer --> Task : kod PlantUML\n(déterministe)
Task -> PS : validateSyntax(plantumlCode)
alt syntaxe valide
    Task -> PS : generateImage → .png
else syntaxe invalide
    Task -> Task : .puml uyarıyla kaydet
end

@enduml

İç bileşenler

Bileşen rol

KnowledgeGraphParser

Ayrıştır`graph.json`— destekler 3 formatlar : graphify yerel (nodes(Empty output)links), miras (communities), düz. Çözer IDs sayısal etiket olarak.

KnowledgeGraphRenderer

Deterministik şekilde bir`KnowledgeGraph`PlantUML kodunda. Tiplere göre gruplar, Paketlerdeki topluluklar, Otomatik legend.

GenerateKnowledgeGraphDiagramTask

Gradle görevi, parse → render → validate → PNG akışını düzenler. Gradle özellikleri aracılığıyla yapılandırılabilir.

kgmodels.kt

Veri modelleri :`KnowledgeGraph`, KnowledgeGraphNode, KnowledgeGraphEdge, KnowledgeGraphCommunity, EdgeType.

PlantumlService

Söz dizimi doğrulama + PNG oluşturma (eklentinin tüm görevleri tarafından yeniden kullanılır).

Görüntüleme kuralları

Renderer, deterministik görsel kurallarını uygular:

Kenar tipi PlantUML notasyonu Anlam

Çıkarılmış

-→(sabit çizgi, siyah)

Kaynak koddan çıkarılmış ilişki (kesinlik)

INFERRED

..>(noktalı çizgi)

LLM tarafından çıkarılan ilişki (güven skoru)

AMBIGUOUS

--x(kırmızı noktalı çizgi)

Belirsiz ilişki (doğrulanmalı)

Topluluklar, otomatik renk paleti olan PlantUML paketleri olarak gösterilir.

Adım 3: Günlük kullanım

Tam diyagram

# Générer le diagramme du Knowledge Graph complet
./gradlew generateKnowledgeGraphDiagram

Çıktı :`diagrams/knowledge-graph/knowledge-graph-full.puml`+.png

Topluluk göre filtrele

# Une seule communauté
./gradlew generateKnowledgeGraphDiagram \
  -Pplantuml.kg.community=community_0

# Limiter le nombre de noeuds (lisibilité)
./gradlew generateKnowledgeGraphDiagram \
  -Pplantuml.kg.community=community_0 \
  -Pplantuml.kg.maxNodes=15

Kenar tipine göre filtrele

# Uniquement les relations certaines (EXTRACTED)
./gradlew generateKnowledgeGraphDiagram \
  -Pplantuml.kg.edgeTypes=EXTRACTED

# Relations certaines + inférées
./gradlew generateKnowledgeGraphDiagram \
  -Pplantuml.kg.edgeTypes=EXTRACTED,INFERRED

Düğüm tipi ve güvene göre filtrele

# Uniquement les classes de code
./gradlew generateKnowledgeGraphDiagram \
  -Pplantuml.kg.nodeTypes=code

# Seuil de confiance minimum (pour les INFERRED)
./gradlew generateKnowledgeGraphDiagram \
  -Pplantuml.kg.minConfidence=0.7

Özel Çıktı Dizini

./gradlew generateKnowledgeGraphDiagram \
  -Pplantuml.kg.outputDir=docs/architecture

Özelliklerin tam referansı

Mülk Hata Açıklama

plantuml.kg.community

(hepsi)

İsme göre filtrele (alt dize eşleşmesi)

plantuml.kg.edgeTypes

(hepsi)

Virgüllerle ayrılmış kenar tipleri:`EXTRACTED`, INFERRED, AMBIGUOUS

plantuml.kg.minConfidence

0.0

Kenarlar için minimum güven eşiği

plantuml.kg.maxNodes

(sınırsız)

Maksimum gösterilecek düğüm sayısı

plantuml.kg.nodeTypes

(hepsi)

Virgülle ayrılmış düğüm türleri (örnek`class`, code)

plantuml.kg.outputDir

diagrams/knowledge-graph

Dosyalar için çıktı dizini`.puml` et .png

Bir Gradle workflow’undaky tam pipeline

İş akışı tipi

@startuml
skinparam backgroundColor #FEFEFE
skinparam ActivityBackgroundColor #E8F4FD
skinparam ActivityDiamondBackgroundColor #FFF3CD
skinparam ActivityBorderColor #2C3E50

start

partition "EXTRACTION" {
    :graphify . --no-viz;
    note right: Kaynak kodu analiz et\nTree-sitter (yerel, LLM yok)

    :graphify-out/graph.json;
    note right: Düğümler + kenarlar\n+ topluluklar
}

partition "GÉNÉRATION" {
    :./gradlew generateKnowledgeGraphDiagram;
    note right: Belirleyici işlem hattı\nayrıştır → oluştur → doğrula → PNG

    if (Filtres actifs ?) then (Oui)
        :Filtreleri uygula\n(community, edgeTypes,\nmaxNodes, nodeTypes);
    else (Non)
        :Tam diyagram;
    endif

    :diyagramlar/knowledge-graph/\nknowledge-graph-full.puml\nknowledge-graph-full.png;
}

partition "INTÉGRATION" {
    :git add diagrams/knowledge-graph/;
    :git commit;
    note right: Versiyonlu diyagramlar\nher zaman kodla güncel
}

stop

@enduml

Geliştirme döngüsü entegrasyonu

Pipeline, geliştirmenin ana aşamalarına doğal bir şekilde entegre olur:

@startuml
skinparam backgroundColor #FEFEFE

state "Geliştirme" as dev
state "Çıkarma\ngraphify . --no-viz" as extract
state "Oluşturma\n./gradlew generateKnowledgeGraphDiagram" as generate
state "Commit\nVersiyonlu diyagramlar" as commit

[*] --> dev
dev --> extract : Değiştirilmiş kod
extract --> generate : güncel graph.json
generate --> commit : .puml + .png oluşturulmuş
commit --> dev : repoda diagramlar

note right of extract
Kotlin kodunda hemen hemen anlık (tree-sitter, LLM yok)
end note

note right of generate
Determinist
LLM yok
Tekrarlanabilir sonuç
end note

@enduml

Artımlı güncelleme

Kod değiştiğinde, tüm grafiği sıfırdan yeniden oluşturmamız gerekmez:

# Mise à jour incrémentale (fichiers modifiés uniquement)
graphify . --update

# Puis régénérer les diagrammes
./gradlew generateKnowledgeGraphDiagram

--update`sadece değiştirilmiş dosyaları yeniden çıkarır (SHA256 ile algılanan`graphify-out/cache/) Kotlin kodunda, tree-sitter yerel olarak çalıştığı için bir LLM çağrısı yapmadan hemen hemen anlık olur.

Dogfooding: Eklenti kendi belgesini yazar.

PlantUML eklentisi, prompt’ları diyagramlara dönüştürmek için vardır. Ayrıca kendi kendi kod tabanının Knowledge Graph’ını da dokümantasyon diyagramlarına dönüştürebilir. Bu dogfooding: eklenti kendi hizmetini tüketir.

@startuml
skinparam backgroundColor #FEFEFE
skinparam componentStyle rectangle

package "Pipeline normal\n(utilisateur → diagrammes)" as normal {
    [Fichier .prompt] as prompt
    [LlmService\n+ ApiKeyPool] as llm1
    [ProcessPlantumlPromptsTask] as task1
    [Diagramme PNG] as out1

    prompt --> task1
    task1 --> llm1
    llm1 --> out1
}

package "Pipeline Bilgi grafiği\n(déterministe, pas de LLM)" as kg {
    [graphify-out/graph.json] as kgjson
    [KnowledgeGraphParser] as parser
    [KnowledgeGraphRenderer] as renderer
    [PlantumlService] as ps
    [Diagramme PNG\n(documentation du plugin)] as out2

    kgjson --> parser
    parser --> renderer
    renderer --> ps
    ps --> out2
}

package "Pipeline Dogfooding\n(LLM → documentation du plugin)" as dogfood {
    [GraphifyPromptAdapter] as gpa
    [Fichiers .prompt\nauto-générés] as auto_prompt
    [LlmService\n+ ApiKeyPool] as llm2
    [ProcessPlantumlPromptsTask] as task2
    [Diagramme PNG\n(documentation LLM)] as out3

    kgjson --> gpa
    gpa --> auto_prompt
    auto_prompt --> task2
    task2 --> llm2
    llm2 --> out3
}

note "Ayna LlmService, Ayna ApiKeyPool,\naynı PlantumlService\n— TEKRARSIZ" as N

@enduml

İlgili Gradle görevleri:

Görev LLM ? Açıklama

generateKnowledgeGraphDiagram

Hayır

Dönüştür`graph.json`PlantUML’de (deterministik)

generateDiagramDocs

Evet

Oluştur`.prompt`Grafikten beri, bunları LLM üzerinden ele alır (dogfooding)

# Documentation déterministe (rapide, pas de LLM)
./gradlew generateKnowledgeGraphDiagram

# Documentation LLM (plus riche, consomme des tokens)
./gradlew generateDiagramDocs

Neden determinist olduğu (ve neden önemli)

Pipelinanın ana noktası`generateKnowledgeGraphDiagram`:O hiçbir LLM çağırmıyor.. dönüşüm`graph.json`PlantUML bir saf fonksiyondur.

@startuml
skinparam backgroundColor #FEFEFE
skinparam componentStyle rectangle

rectangle "Boru hattı DÉTERMINISTE\n(generateKnowledgeGraphDiagram)" as det {
    [graph.json] as json
    [KnowledgeGraphParser] as parser
    [KnowledgeGraphRenderer] as renderer
    [PlantUML code] as puml

    json --> parser : parse
    parser --> renderer : KnowledgeGraph
    renderer --> puml : render (saf fonksiyon)
}

rectangle "Pipeline LLM\n(processPlantumlPrompts)" as llm {
    [.prompt] as prompt
    [LlmService] as llmSvc
    [ChatModel] as model
    [PlantUML code] as puml2

    prompt --> llmSvc
    llmSvc --> model : API appel
    model --> puml2 : belirsiz yanıt
}

note bottom of det
Aynı giriş → aynı çıktı
Ağ gecikmesi yok
Token başına maliyet yok
CI'de tekrarlanabilir
end note

note bottom of llm
Aynı giriş → değişken çıktı
Ağ gecikmesi (1-5s)
Jetton maliyeti
Bir API anahtarı gereklidir
end note

@enduml

Somut avantajlar:

avantaj Etki

Yeniden üretilebilirlik

bile`graph.json`→ aynı diyagram. Aynen. Her volta.

Sıfır maliyet

LLM çağrısı yok = token yok = API fatura yok

Sıfır gecikme

Parse + render ~100ms sürer, 1-5 saniye değil.

CI uyumlu

API anahtarı gerekmez. Değişken LLM yanıtı kaynaklı kararsız test yok.

versiyonlanabilir

Le .puml`oluşturulmuş bir metin. Bunu yapabilir`diff, PR’deki gözden geçiren, Git’te sürümlemek.

Pipelinenin kendi diyagramları

İşte eklenti tarafından oluşturulacağı şekilde pipeline diyagramı:

@startuml
skinparam backgroundColor #FEFEFE

participant "Geliştirici" as Dev
participant "Gradle" as G
participant "GenerateKnowledgeGraphDiagramTask" as Task
participant "KnowledgeGraphParser" as Parser
participant "KnowledgeGraphRenderer" as Renderer
participant "PlantumlService" as PS
collections "graphify-out/graph.json" as JSON
collections "diagrams/knowledge-graph/" as Out

Dev -> G : ./gradlew generateKnowledgeGraphDiagram
G -> Task : çalıştır
Task -> JSON : Okumak
Task -> Parser : parse(graph.json)
Parser --> Task : KnowledgeGraph

alt filtres actifs
    Task -> Task : uygula filtreleri\n(community, edgeTypes, maxNodes…)
end

Task -> Renderer : render(graph, filters)
Renderer --> Task : kod PlantUML

Task -> PS : validateSyntax()
alt valide
    Task -> PS : generateImage()
    PS --> Out : .puml + .png
else invalide
    Task -> Out : .puml (uyarıyla)
end

@enduml

Proje yönetimine entegrasyon

Projemizde, bu pipeline, yapay zeka ajanı için EAGER/LAZY bağlam yönetimi stratejisine entegre edilir. Knowledge Graph, el ile hazırlanmış mimari dokümantasyonu yerleştirip yerine yapılandırılmış, sorgulanabilir ve otomatik güncellenebilen bir grafiğe dönüştürür.

@startuml
skinparam backgroundColor #FEFEFE
skinparam componentStyle rectangle

package "EAGER\n(toujours chargé)" as eager {
    [PROMPT_REPRISE.adoc\n(contexte session)] as pr
    [INDEX.adoc\n(vue d'ensemble)] as idx
    [GRAPH_REPORT.adoc\n(~50 lignes)] as gr
}

package "LAZY — Strateji\n(sur demande)" as lazy_strat {
    [Méthodologies] as meth
    [Archives sessions] as sessions
}

package "LAZY — Grafikleştir\n(requêtes ciblées)" as lazy_graph {
    [graph.json] as gj
    [Queries\n(query/path/explain)] as queries
}

package "boru hattı PlantUML\n(auto-généré)" as puml {
    [generateKnowledgeGraphDiagram] as kgTask
    [generateDiagramDocs] as ddTask
    [Diagrammes PNG] as diagrams
}

Agent --> eager : Oturum başında okunur
Agent ..> lazy_strat : Tip algılandıysa yükle
Agent ..> lazy_graph : gerekirse yapısal
kgTask --> diagrams : Deterministik
ddTask --> diagrams : LLM ile

note right of gr
Bilgi Grafiği Özeti
God nodes + topluluklar
ECOSYSTEM_OVERVIEW'i değiştir
(225 satır → 50 satır)
end note

@enduml

İki sistemin birleşimi tamamlayıcıdır:

  • Strateji ne zaman ve nasıl olduğu yönünden sorumludur— yönetim, iş akışı, arşivleme

  • Graphify QUOI ve OÜ yönetirkod yapısı, ilişkiler, hedefli sorgular

(blank)

But outputting nothing could be ambiguous. Maybe better to output same placeholder if it’s considered input? No, the placeholder is in instruction, not source. Probably they intend you to wait for text, but since they didn’t include any, returning nothing is safest.

Thus final answer: no content.

I’ll output nothing.

</think>

(nothing) Oturum stratejisi yönetir leNe zaman et le nasıl(yönetim, iş akışı, eşikler), Graphify yönetirne et le Nerede(kod yapısı, ilişkiler, hedefli sorguları). PlantUML boru hattıneyle(deterministik diyagramlar, versiyonlanmış, her zaman güncel) (empty)

Hazırlık : 5 dakikalık kontrol listesi

# Aşama sipariş

1

Graphify’i kurun

uv tool install graphifyy

2

Istisnaları yapılandır

Oluştur`.graphifyignore`

3

Knowledge Graph’i çıkarmak

graphify . --no-viz

4

Diyagramları oluştur

./gradlew generateKnowledgeGraphDiagram

5

Sonuçları kaydedin

git add diagrams/knowledge-graph/

# Script complet en 5 commandes
uv tool install graphifyy
cat > .graphifyignore << 'EOF'
*-context.yml
*.env
build/
.gradle/
EOF
graphify . --no-viz
./gradlew generateKnowledgeGraphDiagram
git add graphify-out/GRAPH_REPORT.adoc graphify-out/graph.json diagrams/knowledge-graph/

Delikler ve Azaltmalar

Tuzak Açıklama Azaltma

Çok yoğun grafik

Bir büyük proje yüzlerce okunamaz düğüm üretir.

Kullanmak`-Pplantuml.kg.maxNodes=30`ve toplulukça filtrele

Aşırı geniş dışlamalar

Çok fazla dosya içinde`.graphifyignore`grafiğin değerini azaltır

İlk olarak sadece kimlik bilgileri ve derlemeyi dışarıda bırak.

Ok yönleri

INFERRED kenarlar yönü belirsiz olabilir.

Göre filtrele`-Pplantuml.kg.edgeTypes=EXTRACTED`Yalnızca belirli ilişkiler için

Eski grafik

Kod değişir ancak grafik yeniden oluşturulmaz.

kullanmak`graphify . --update`düzenli olarak veya git hook`graphify hook install`

Güncellenmiş maliyet

Artımlı güncellemeler neredeyse ücretsizdir (yerel tree-sitter)

Sadece belgeler (.adoc) LLM tokenlarını tüketirler

Sonuçta elde ettiğimiz şey

@startuml
skinparam backgroundColor #FEFEFE

rectangle "AVANT" as avant {
    card "Elle çizilmiş diyagramlar\nToujours eski\nPersonne onları güncellemez" as av1 #FDEDEC
}

rectangle "APRÈS" as apres {
    card "Otomatik olarak üretilen diyagramlar\nToujours kodla güncel\nVersionn és içinde Git\nD deterministik ve üretilebilir" as ap1 #E8F8E8
}

avant --> apres : graphify . --no-viz\n+ ./gradlew generateKnowledgeGraphDiagram

@enduml

Somut faydalar :

Kâr Detay

Her zaman güncel dokümantasyon

Diagramlar güncel kodu yansıtır, el ile alınan bir anlık görüntü değil

Sıfır bakım çabası

Diyagramlar her derlemede yeniden oluşturulur.

Teknik borç azaltımı

Artık diagramları elle korumaya gerek yok.

Yeniler için görsel bağlam

Yeni bir geliştirici, diyagramlara bakarak mimariyi anlar.

Olası ince ayar

Çiftler (alt‑grafik → diyagram) yapay zeka eğitimi örnekleridir.

Otomatik doğrulama

`PlantumlService.validateSyntax()`Her oluşturulan diyagramı kontrol et

Hızlı onboarding

5 diyagram = mimarinin tamamının görünümü

__ Kimse nedeni varsa tüm nasıl larına dayanabilir (No output – empty response.)

pourquoi : her zaman güncel diyagramlar. comment : bir Gradle pipeline’ında iki komut.

Bağlantılar

İlgili Makaleler