squid-protocol1/gitgalaxyMotore di knowledge graph euristico senza AST per un'intelligenza approfondita dei repository e scansione di sicurezza zero-trust. Si integra come componente GitLab CI/CD, blocca il codice ostile ed esporta la telemetria SARIF nel GitLab Security Dashboard.
# GitGalaxy
**Intelligenza strutturale su scala di repository senza compilazione.**
[Docs](https://squid-protocol.github.io/gitgalaxy/) ·
[Visualizer](https://gitgalaxy.io/) ·
[Language Crucible](https://github.com/squid-protocol/language-crucible) ·
[Keyword Rosetta](https://github.com/squid-protocol/keyword-rosetta) ·
[Raw Output](https://github.com/squid-protocol/gitgalaxy-raw-output)
**1 scansione · 97 segnali strutturali · 50+ linguaggi · nessuna compilazione · 17
categorie di esposizione al rischio · 6 output**
## La versione breve
GitGalaxy costruisce un **grafo strutturale agnostico rispetto al linguaggio dell'intero
repository** direttamente dal testo sorgente — nessuna build, nessuna toolchain per linguaggio.
È progettato per repository poliglotti, parzialmente non funzionanti, legacy,
pieni di codice di terze parti, o altrimenti difficili da analizzare tramite un flusso di lavoro build-first:
``` text
Go + C++ + Python + Java + Bash + YAML
+ generated code + vendored code + legacy code
+ half-migrated modules + broken dependencies
```
Invece di un parser separato per ogni linguaggio, GitGalaxy estrae un
vocabolario comune di **firme strutturali** — funzioni, classi, argomenti,
flusso di controllo, mutazione dello stato, I/O, API, dipendenze — e le normalizza
in un unico modello di repository deterministico che alimenta l'analisi
architetturale, la prioritizzazione dell'esposizione al rischio, la generazione
di SBOM, il refactoring e l'analisi della proprietà, il contesto di codebase
orientato all'AI e i gate CI/CD.
> **Tesi centrale:** il parsing completo del linguaggio non è sempre necessario
> per recuperare informazioni strutturali altamente utili su scala di repository.
Come questa tesi viene verificata — rispetto a Tree-sitter e Ctags, rispetto a
un corpus di controllo piantato, e in seguito rispetto alla cronologia Git — è
riassunto in [Precisione, misurata](#accuracy-measured) di seguito ed è
esposto in dettaglio nel [programma di validazione](https://gitlab.com/squid-protocol1/gitgalaxy/-/blob/main/docs/validation.md).
------------------------------------------------------------------------
## Cosa ti offre una scansione
Un solo comando:
``` bash
pip install gitgalaxy
galaxyscope path/to/repo
```
Sei viste coordinate della stessa scansione deterministica:
| Output | Scopo |
|---|---|
| **Brief sull'architettura per LLM** | Contesto compatto orientato a macchine/agenti (di seguito) |
| **SARIF** | Integrazione con CI/dashboard di sicurezza |
| **CycloneDX SBOM** | Inventario delle dipendenze/conformità |
| **SQLite** | Grafo di conoscenza del repository interrogabile |
| **Dati di audit JSON** | Flussi di lavoro forensi/di automazione |
| **Dati di visualizzazione 3D** | Topologia interattiva del repository |
### Il brief sull'architettura
Il report di punta è un singolo brief Markdown costruito per consegnare a un ingegnere — o
a un agente AI — un modello mentale funzionante di un repository che non ha mai visto. È
un pacchetto autonomo: le equazioni di rischio sono stampate nel report stesso,
e un prompt di interpretazione incorporato consente a qualsiasi LLM di narrarlo senza
allucinare sul significato dei numeri. Le sezioni coprono lo stato macro e la composizione
linguistica, la topologia di rete (modularità, punti di articolazione, densità
ciclica), i colli di bottiglia delle dipendenze, le funzioni e i file più pesanti, le firme
strutturali per file con raggio d'impatto PageRank, le hitlist di rischio mirato e cumulativo,
gli audit della supply chain e gli obiettivi di refactoring classificati per volatilità e
centralizzazione della paternità — più un elenco dettagliato di ogni file che ha *rifiutato* di
scansionare, e il perché.
Due esempi, scansionati il 2026-08-31 con il motore attuale. Entrambi i repository
sono pubblici — clona l'uno o l'altro ed esegui `galaxyscope --llm-only <path>` per riprodurre
il brief completo:
**curl** — 4.250 artefatti, 696 scansionati, 112.653 LOC tra C, Perl, Python,
Shell, M4 e Makefile. Il brief classifica `src/tool_setup.h` come il principale
pilastro strutturale (80 connessioni in entrata) e colloca una funzione *Perl* —
`APPEND_imap` in `tests/ftpserver.pl`, Impatto 2135, 1.672 LOC — in cima alla
hitlist delle funzioni a livello di repository, nella stessa classifica del codice C. Quel
grafo cross-linguaggio è il prodotto: un insieme di segnali comparabili in ogni
linguaggio del repository. L'avvertenza onesta nello stesso brief: solo il 16,4% degli
artefatti è stato scansionato — il filtro di ingestione scarta aggressivamente binari, codice
generato e dati di test, e la §5 del brief elenca ogni esclusione per
estensione e motivo.
**cics-genapp** (il campione CICS COBOL/DB2 di IBM) — 92,1% scansionato: 44 programmi
COBOL, 29 job JCL. La hitlist cumulativa della superficie strutturale è guidata da
`base/src/lgupdb01.cbl` (superficie di mutazione ~100%, carico di complessità 92%), e il
paragrafo più pesante del repository è `UPDATE-POLICY-DB2-INFO` — la logica di row-locking
`SELECT FOR UPDATE`, che è esattamente dove un manutentore di quel programma
vorrebbe guardare per primo. Lo stesso brief mostra anche chiaramente un limite: su
un'architettura piatta senza un vero grafo di import, la lista dei "pilastri
strutturali" degenera in file a zero connessioni, e il report dice di controllare i
conteggi delle connessioni prima di fidarsi.
Centinaia di brief non modificati per repository selezionati in modo indipendente sono
committati su
[gitgalaxy-raw-output](https://github.com/squid-protocol/gitgalaxy-raw-output);
il brief di auto-scansione sempre aggiornato di questo stesso repository è su
[`docs/gitgalaxy_architecture_brief.md`](https://gitlab.com/squid-protocol1/gitgalaxy/-/blob/main/docs/gitgalaxy_architecture_brief.md).
### Un grafo, molti consumatori
| Consumatore | Domanda |
|---|---|
| Architettura | Di cosa è fatto questo repository? |
| Analisi strutturale | Dove sono le funzioni, le classi, le API, le dipendenze e le strutture di controllo? |
| Structural Surface Profile (ex Risk exposure) | Dove è concentrato un dato pattern strutturale/di contenuto? |
| Refactoring | Quali file sono complessi, ad alto churn o portanti? |
| Supply chain | Quali dipendenze esistono fisicamente su disco? |
| Contesto AI | Quale architettura e quali relazioni dovrebbe conoscere un agente? |
| Migrazione legacy | Dove sono le unità strutturali da trasformare? |
| Analisi storica | Come cambia l'esposizione misurata man mano che il repository evolve? |
------------------------------------------------------------------------
## Accuratezza, misurata
Due programmi di misurazione permanenti supportano le affermazioni precedenti, e un terzo, per i
grafi delle dipendenze e delle chiamate, è in corso. La narrazione completa —
metodologia, verdetti, limiti e cosa viene dopo — è in
[il programma di validazione](https://gitlab.com/squid-protocol1/gitgalaxy/-/blob/main/docs/validation.md); questa è la sintesi.
### Validazione strutturale: GitGalaxy vs Tree-sitter vs Ctags
GitGalaxy è confrontato con **Tree-sitter e Universal Ctags** sul
corpus fissato [Language Crucible](https://github.com/squid-protocol/language-crucible)
— 24 dei 45 linguaggi ricevono tutti e tre gli strumenti, altri 13 ne ricevono due, e ogni
discrepanza viene investigata sul codice sorgente reale e registrata con un verdetto
(200 delle 201 forme di discrepanza registrate validate). Su quel corpus, la precisione
delle funzioni validate di GitGalaxy è del 100% in tutti i 31 linguaggi confrontabili con
tree-sitter, e non è mai lo strumento trovato in errore in una classe o
disaccordo sugli argomenti validato. Il limite: tre obiettivi strutturali, un corpus fisso —
non "analizza con la stessa accuratezza di un AST" in generale.
### Validazione del grafo: import e chiamate (in corso)
Il raggio d'impatto, il PageRank e i "pilastri strutturali" derivano dal **grafo degli import**. Le
classifiche a livello di funzione derivano dal **grafo delle chiamate**. Nessuno dei due grafi è misurato in ogni
linguaggio ancora, e il grafico sottostante indica quali lo sono:
- I linguaggi misurati mostrano precisione e richiamo con n.
- Ogni linguaggio non ancora misurato è elencato per nome.
Al 2026-09-26, su 59 linguaggi:
- **Il grafo degli import è misurato in 20.** Gli archi del motore sono verificati rispetto alle
istruzioni di import di ciascun linguaggio su repository reali fissati
([`import_graph_accuracy.py`](https://gitlab.com/squid-protocol1/gitgalaxy/-/blob/main/tests/tools/import_graph_accuracy.py)).
- **I nomi dei chiamati sono misurati in 11**, rispetto a tree-sitter.
- **La risoluzione delle chiamate è misurata in 3**, rispetto a un analizzatore di riferimento:
- Python, vs pyan3: 99,8% di precisione su 1.806 link giudicati, 51,6% di richiamo;
- TypeScript, vs il type checker di TypeScript 6.0.2: 99,9% di precisione su 1.520 link giudicati,
57,1% di richiamo;
- Java, vs scip-java (la risoluzione di javac stesso): 92,7% di precisione su 3.474 link giudicati,
41,0% di richiamo. Una chiamata a un metodo sovraccaricato viene collegata solo quando il suo numero di argomenti seleziona
un overload ([#3835](https://github.com/squid-protocol/gitgalaxy/issues/3835)).
Un link di chiamata, quando viene creato, è di solito corretto, ma circa la metà o più delle chiamate rimane
non collegata. Quindi il fan-in a livello di funzione e il PageRank sono un limite inferiore.
I limiti:
- I grafi degli altri 38 linguaggi sono costruiti allo stesso modo ma **non sono misurati**.
- Diversi linguaggi misurati si basano su un solo repository con meno di 100 import. Il grafico
attenua quelli.
- Un `*` contrassegna un numero con discrepanze ancora in attesa di un verdetto rispetto al sorgente.
Il piano per colmare queste lacune è
[epic #3772](https://github.com/squid-protocol/gitgalaxy/issues/3772).
### Coerenza cross-linguaggio: il corpus di controllo Keyword Rosetta
Il programma più recente pone la domanda opposta: **GitGalaxy misura
un intento identico allo stesso modo in ogni linguaggio?** Il
corpus [keyword-rosetta](https://github.com/squid-protocol/keyword-rosetta)
pianta lo stesso programma a 12 sonde in tutti i 50 linguaggi supportati con conteggi
di segnale esatti e noti — quindi qualsiasi divergenza è un bias linguistico misurato, per costruzione.
Il grafico colora ogni deviazione per *causa*, non per dimensione: il rosso è un
difetto aperto del motore (una regola che corrisponde al costrutto sbagliato, o un peso di punteggio che si trova dentro
un conteggio); il grigio è una variazione documentata che il ledger ha validato — il linguaggio
non può esprimere il costrutto, una scelta di punteggio deliberata, o un'eco di un'altra
riga. Risposta attuale: in media il 94% dei linguaggi rientra entro ±25% dalla
mediana cross-linguaggio per metrica gated (56 metriche rappresentabili, 54 con ≥80%),
e **la quota di difetti aperti è dello 0,0% (1 su 2.844 celle comparabili in 59 metriche
gated)** — una singola cella inspiegata, `classes_found` nel corpus `bms` (CICS Basic Mapping
Support) appena piantato; ogni altra cella fuori banda è una
variazione che il ledger ha validato (uno strato di severità, un costrutto che il
linguaggio non può esprimere, un'eco di un'altra riga, o una scelta di punteggio
deliberata), non un difetto aperto del motore. Le metriche più deboli sono nominate anziché
nascoste — `cog_raw` mantiene il 74% dei linguaggi in banda, `raw_arch_api` il 78%,
`avg_func_args` l'80% — ma le loro celle sotto-banda sono documentate, non difetti.
L'affermazione sopravvive anche all'espansione: quando il corpus ha piantato la sua prima
sonda con lente di sicurezza — un identico segreto hardcoded in ogni linguaggio —
`credential_material` (ex `risk_secrets_risk`; il nome `risk_*` rimane
la colonna del DB — vedi [`docs/vectors.md`](https://gitlab.com/squid-protocol1/gitgalaxy/-/blob/main/docs/vectors.md)) ha letto un **punteggio
uniforme in tutti i 50 linguaggi** (un identico 25.000 per colonna). Le due
eccezioni di formato inerte che la lente originariamente saltava, e la dipendenza misurata
dalla lunghezza della formula, sono state registrate nel ledger e segnalate lo stesso giorno
([#2978](https://github.com/squid-protocol/gitgalaxy/issues/2978),
[#2979](https://github.com/squid-protocol/gitgalaxy/issues/2979)). La #2978 è
chiusa: la lente ora gira su tutti e cinque i formati inerti
(plaintext/markdown/json/yaml/csv), con un opt-out di configurazione `SECURITY_SCAN_INERT_FORMATS`
per i repository in cui ciò scambia troppo rumore di doc/config per la
copertura, e la ri-verifica del corpus di keyword-rosetta rispetto alla correzione unita
ora si colloca interamente in banda (la voce `secrets-lens-inert-formats` del ledger).
Ogni deviazione è registrata in un ledger validato, il lavoro è tracciato per famiglia di causa
sotto la [roadmap dei contratti](https://gitlab.com/squid-protocol1/gitgalaxy/-/blob/main/docs/contract_roadmap.md), e
le classi di difetti trovate in questo modo sono
[segnalate come issue di GitGalaxy](https://github.com/squid-protocol/keyword-rosetta/blob/main/docs/findings_by_language.md).
Un corpus di controllo dimostra la disuguaglianza di misurazione su intento identico; non dice
nulla sull'accuratezza su codice reale (il compito del tri-confronto sopra) — e un
bias costante per file preserva comunque la classifica *all'interno* di un linguaggio. Il
[report di incidenza](https://github.com/squid-protocol/keyword-rosetta/blob/main/docs/incidence_report.md)
dimensiona ogni forma confermata rispetto a codice reale con licenza.
------------------------------------------------------------------------
## Scala nel mondo reale
Esempio: **Kubernetes** — ~1,39M di righe tra Go, YAML, JSON, Shell e Proto.
Scansione end-to-end: **50,83 secondi**. Il tempo di scansione segue un modello a due regimi adattato
(piatto ~0,11s sotto ~4,3K LOC, poi `time(s) ≈ 3.36e-05 × LOC^0.969`, R²=0,88
su 599 repository) — quindi una manciata di outlier da 20M+ LOC richiede comunque minuti, e una
scansione veloce dimostra il throughput, non la qualità dell'analisi; la questione dell'accuratezza è
gestita separatamente di seguito.
Vedi il [repository di output
grezzo](https://github.com/squid-protocol/gitgalaxy-raw-output) per
artefatti non modificati.
------------------------------------------------------------------------
# Structural Surface Profile: cosa afferma GitGalaxy (ex "Risk exposure")
I 13 vettori per file di GitGalaxy erano originariamente chiamati `risk_*` e descritti come
**misurazioni di esposizione al rischio**. La domanda che questa sezione lasciava aperta —
"queste firme sono empiricamente associate a classi significative di
rischio software?" — è stata da allora testata, non solo posta. Il
programma di validazione temporal-crucible (epic
[#2982](https://github.com/squid-protocol/gitgalaxy/issues/2982), ~3.550
snapshot scansionati, due repository, tre famiglie di etichette, ogni test pre-registrato prima
che i dati fossero esaminati) ha eseguito quell'esperimento fino all'esaurimento, e il risultato
onesto ha portato a un rinomino
([#2991](https://github.com/squid-protocol/gitgalaxy/issues/2991)): i
vettori sono ora chiamati **Structural Surface Profile**. `risk_*` rimane
il nome della colonna DB / chiave JSON per compatibilità (vedi
[`docs/vectors.md`](https://gitlab.com/squid-protocol1/gitgalaxy/-/blob/main/docs/vectors.md) per la tabella completa dei nomi e la
nota di deprecazione).
**Cosa ha trovato il registro, riformulato onestamente:**
- **Rischio permanente per file, falsificato.** L'ipotesi fondante — che il livello
`risk_*` di un file, o il suo cambiamento dopo una correzione, tracci la probabilità
di difetto — non ha retto. Il delta strutturale mediano dopo una correzione di sicurezza
era +0,000 (equivalenza confermata vicino allo zero su un secondo repository
indipendente, non solo non significativo); l'esposizione strutturale sommata si è classificata
*ultima* tra sei feature per predire i file toccati da correzioni; un vettore strutturale
multivariato a 26 segnali ha ottenuto un punteggio pari al caso (AUC 0,479) sotto uno
split temporale, sotto un semplice conteggio di righe (0,531). Il ledger completo è in
`docs/HYPOTHESES.md` di temporal-crucible ed è collegato da
[#2982](https://github.com/squid-protocol/gitgalaxy/issues/2982).
- **Per cosa i vettori hanno effettivamente validato:** descrivere **attività e
contenuto**, non la probabilità di difetto. Il composito a forma di correzione traccia
in modo affidabile un gradiente correzione-di-sicurezza → correzione-ordinaria → controllo → revert; i delta
corrispondono a eventi reali del codice (codice di guardia aggiunto, threading introdotto,
marcatori di debito diluiti). Questa è la radiografia che questo documento ora nomina
accuratamente — vedi [`docs/vectors.md`](https://gitlab.com/squid-protocol1/gitgalaxy/-/blob/main/docs/vectors.md) vettore per vettore.
- **Segnale a livello di sistema / storico, riformulato come l'effettiva scoperta
predittiva.** Due feature *sono* sopravvissute alla validazione: **recidivismo** (il file
che ha avuto l'ultima correzione riceve la successiva — il singolo risultato più replicato
del programma, p<1e-4 su entrambi i repository) e **entropia del cambiamento /
Hassan HCM**, validata fuori-selezione su etichette di bug fresche (AUC 0,868 vs
0,830 di un conteggio di righe). Entrambe sono metriche di **storia**, non metriche di contenuto
strutturale — ed entrambe sono attualmente azzerate in ogni scansione
(`GITGALAXY_DISABLE_GIT_HISTORY`, tracciato in
[temporal-crucible#29](https://github.com/squid-protocol/temporal-crucible/issues/29)).
Questo è il seme di un **livello predittivo** separato e onestamente nominato — i
vettori `hist_stability`/`hist_churn` sono nominati per marcare esplicitamente quello stato
— vincolato al rilascio della modalità con storia abilitata e poi al superamento del
contratto di promozione del defect-lift della
[#2987](https://github.com/squid-protocol/gitgalaxy/issues/2987).
Una lettura elevata dello Structural Surface Profile significa:
> **Questa posizione ha più di un dato pattern strutturale/di contenuto presente,
> rispetto al resto del repository.**
Non significa:
> "Questo codice ha più probabilità di contenere un difetto" — la versione per file di
> quell'affermazione è stata testata e non ha retto.
Le firme sottostanti coprono pattern che coinvolgono aree come:
- segreti
- superficie di injection
- operazioni unsafe/memoria
- esecuzione dinamica
- I/O
- concorrenza
- mutazione di stato
- reflection
- API
- dipendenze
- entropia
- altre caratteristiche strutturali/di sicurezza
Vedi [`docs/vectors.md`](https://gitlab.com/squid-protocol1/gitgalaxy/-/blob/main/docs/vectors.md) per la tabella di rinomino per vettore,
le evidenze e gli usi appropriati/inappropriati, e
`docs/HYPOTHESES.md` di
[temporal-crucible](https://github.com/squid-protocol/temporal-crucible) per il ledger di validazione completo che questa sezione riassume.
------------------------------------------------------------------------
# Evidenze, non solo affermazioni
### Language Crucible
Un corpus fissato di codice sorgente reale che include progetti come Godot, Roslyn,
curl, Kubernetes e il software di volo dell'Apollo 11.
[Language Crucible](https://github.com/squid-protocol/language-crucible)
### Regressione golden-master
Il codice sorgente reale viene ri-scansionato e confrontato con l'output atteso committato, così
i cambiamenti del parser hanno un diff osservabile. Rigenerato con
[`tests/tools/update_golden_master.py`](https://gitlab.com/squid-protocol1/gitgalaxy/-/blob/main/tests/tools/update_golden_master.py),
mai modificato a mano.
### Tri-confronto
Lo stesso corpus viene analizzato con GitGalaxy, Tree-sitter e Ctags dove
esiste copertura — 24 dei 45 linguaggi ricevono tutti e tre gli strumenti, 200 delle 201 discrepanze
registrate validate. Sul corpus fissato, GitGalaxy non è mai lo strumento
trovato in errore in un disaccordo validato su precisione delle funzioni, classi o argomenti,
e uguaglia il richiamo delle funzioni di tree-sitter ovunque tranne una definizione shell annidata
che salta per design. Vedi
[la metodologia](https://gitlab.com/squid-protocol1/gitgalaxy/-/blob/main/docs/self_scan/tri_comparison_README.md) e
[il programma di validazione](https://gitlab.com/squid-protocol1/gitgalaxy/-/blob/main/docs/validation.md) per il quadro completo e i suoi
limiti.
### Corpus di controllo Keyword Rosetta
Lo stesso programma a 12 sonde piantato in tutti i 50 linguaggi supportati con esatti
conteggi di segnale noti, che misura la coerenza cross-linguaggio di ogni metrica —
con un ledger di deviazioni validato e i difetti del motore risultanti
[segnalati come issue](https://github.com/squid-protocol/keyword-rosetta/blob/main/docs/findings_by_language.md).
[Keyword Rosetta](https://github.com/squid-protocol/keyword-rosetta)
### Output grezzo del repository
L'output non modificato di GitGalaxy è conservato per centinaia di repository
selezionati in modo indipendente.
[Raw Output](https://github.com/squid-protocol/gitgalaxy-raw-output)
### Suite di regressione
**7.043 test** nella suite predefinita (`python -m pytest tests/`), di cui
**6.165** sono test per-firma in tutti i 45 linguaggi con firma strutturale
— corrispondenze positive, esclusioni esplicite e input
avversariali/ReDoS. Vedi [`tests/README.md`](https://gitlab.com/squid-protocol1/gitgalaxy/-/blob/main/tests/README.md) per la ripartizione, e
[`docs/why_gitgalaxy_beats_ast_here.md`](https://gitlab.com/squid-protocol1/gitgalaxy/-/blob/main/docs/why_gitgalaxy_beats_ast_here.md)
per casi specifici e documentati in cui questa estrazione batte una lettura AST.
### Temporal Crucible (validazione storica)
Se lo Structural Surface Profile corrisponda a eventi reali di sicurezza e
manutenzione nella storia di Git non è più una domanda aperta — è stato
testato. Il programma [Temporal Crucible](https://github.com/squid-protocol/temporal-crucible)
ha scansionato ~3.550 snapshot di repository in due repository (curl, nDPI)
e tre famiglie di etichette (commit di correzione/introduzione CVE, etichette di bug, famiglie CWE),
con ogni test di conferma pre-registrato prima che i dati fossero esaminati. Cosa
ha trovato, detto onestamente:
- **Il rischio strutturale permanente per file non predice i difetti** — si riduce
a un conteggio di righe, un nullo confermato da test di equivalenza su un secondo
repository indipendente (non semplicemente "non significativo").
- **Due metriche di *storia* invece predicono**: il recidivismo (il file che ha avuto l'ultima
correzione riceve la successiva — p<1e-4 su entrambi i repository, il risultato più replicato
del programma) e l'entropia del cambiamento (Hassan HCM), validata
fuori-selezione su etichette di bug fresche.
- **La struttura descrive; la storia predice.** Più predizioni sono morte nel
ledger di quante vi siano sopravvissute — questa è la disciplina della pre-registrazione che funziona,
non una delusione.
Il registro completo è pubblico e riproducibile: il
[ledger delle ipotesi](https://github.com/squid-protocol/temporal-crucible/blob/main/docs/HYPOTHESES.md)
pre-registrato e un [indice predittore × esito](https://github.com/squid-protocol/temporal-crucible/blob/main/docs/EXPERIMENTS.md)
di tutto ciò che il programma ha tentato di correlare. Design e metodo:
[il programma di validazione](https://gitlab.com/squid-protocol1/gitgalaxy/-/blob/main/docs/validation.md#the-next-validation-risk-over-git-history).
[Temporal Crucible](https://github.com/squid-protocol/temporal-crucible)
------------------------------------------------------------------------
# Cos'è GitGalaxy --- e cosa non è
### GitGalaxy è
- intelligence strutturale su scala di repository
- analisi del codice sorgente agnostica rispetto al linguaggio
- una rappresentazione strutturale comune tra codice eterogeneo
- prioritizzazione dell'esposizione al rischio
- mappatura dell'architettura
- generazione di evidenze nativa per la CI
- utile su repository rotti/non compilati
- progettato per il funzionamento locale/offline
### GitGalaxy non è
- un sostituto dell'analisi approfondita del dataflow di CodeQL
- un sostituto dell'ecosistema di regole di Semgrep
- un sostituto dei database CVE delle dipendenze
- una prova di sfruttabilità
- un analizzatore runtime
- un parser completo di linguaggi
- una garanzia che un'esposizione elevata sia una vulnerabilità
| Strumento | Domanda principale |
|---|---|
| **GitGalaxy** | Che aspetto ha, strutturalmente, l'intero repository e dove dovrebbe concentrarsi prima l'attenzione? |
| Tree-sitter | Quale struttura sintattica contiene questo sorgente? |
| Ctags | Dove si trovano le entità di codice navigabili? |
| Semgrep | Questo codice corrisponde a un pattern specificato? |
| CodeQL | Quali relazioni dati/controllo può stabilire un'analisi più approfondita? |
| Strumenti SCA/CVE | Questa dipendenza/versione è associata a un avviso noto? |
------------------------------------------------------------------------
# Cronologia Git e architettura
GitGalaxy incorpora già la cronologia Git in segnali come churn,
concentrazione dei contributori, esposizione al bus-factor, hotspot di
refactoring, proprietà dei file e attività temporale. La direzione di ricerca
è estendere questo da **cronologia come segnale contestuale** a **cronologia
come fonte di validazione esterna per il modello di esposizione** — il design
dell'esperimento è in
[il programma di validazione](https://gitlab.com/squid-protocol1/gitgalaxy/-/blob/main/docs/validation.md#the-next-validation-risk-over-git-history).
------------------------------------------------------------------------
# Privacy e deployment
GitGalaxy è progettato per operare in locale e in ambienti air-gapped.
- Il codice sorgente non viene inviato a un servizio cloud di GitGalaxy.
- La scansione e la vettorizzazione avvengono localmente.
- Lo scanner non ha requisiti di rete a runtime.
- L'esecuzione CI/CD può rimanere all'interno dell'ambiente dell'utente.
- Il visualizzatore nel browser opera su dati forniti localmente.
------------------------------------------------------------------------
# Installazione
``` bash
pip install gitgalaxy # zero install dependencies
pip install "gitgalaxy[full]" # + tiktoken, xgboost, pandas, numpy, pyyaml
```
Consulta la [documentazione](https://squid-protocol.github.io/gitgalaxy/) per
i comandi e la configurazione attuali.
### Modalità zero-dependency
Un semplice `pip install gitgalaxy` non introduce nulla, per ambienti in cui
ogni pacchetto di terze parti è una questione di supply-chain. Le scansioni
vengono comunque eseguite: ogni segnale strutturale, arco di dipendenza, conteggio in/out-degree, PageRank / blast
radius, betweenness, closeness, lunghezza media del percorso, modularità, densità
ciclica, punti di articolazione e assortatività viene misurato esattamente come in piena
precisione (questi sono calcolati nativamente). Ciò che richiede i motori opzionali è
la massa di token e il costo di lettura (`tiktoken`), la classificazione ML delle minacce
(`xgboost`/`pandas`/`numpy`) e il parsing di configurazioni YAML/OpenAPI
(`pyyaml`). Una metrica non calcolata viene riportata come assente (`n/a` /
NULL), mai come zero. Ogni output indica quando una scansione è stata eseguita in questa modalità, e
[`docs/zero_dependency_mode.md`](https://gitlab.com/squid-protocol1/gitgalaxy/-/blob/main/docs/zero_dependency_mode.md) elenca, campo per
campo, ciò che è identico e ciò che non è disponibile.
### CI/CD
Sono forniti template per GitHub Actions, GitLab CI, Bitbucket Pipelines,
Azure Pipelines e ambienti CI generici invocabili da shell. Vedi
[`templates/`](https://gitlab.com/squid-protocol1/gitgalaxy/-/blob/main/templates) e la [guida all'integrazione
CI](https://gitlab.com/squid-protocol1/gitgalaxy/-/blob/main/github-action-readme.md).
------------------------------------------------------------------------
# Esplora le prove
| Risorsa | Cosa contiene |
|---|---|
| [Documentazione](https://squid-protocol.github.io/gitgalaxy/) | Architettura, affermazioni e metodologia |
| [Il programma di validazione](https://gitlab.com/squid-protocol1/gitgalaxy/-/blob/main/docs/validation.md) | La narrazione completa della dimostrazione: tesi, benchmark, scala di validità, prossimi esperimenti |
| [Riferimento dei vettori](https://gitlab.com/squid-protocol1/gitgalaxy/-/blob/main/docs/vectors.md) | I 13 vettori per file: nomi, significato, prove e la nota di deprecazione `risk_*` |
| [Fatti sulle formule dei vettori](https://gitlab.com/squid-protocol1/gitgalaxy/-/blob/main/docs/vector_formulas.md) | Audit meccanico delle formule per calcolatore (input, aritmetica, costanti) |
| [Language Crucible](https://github.com/squid-protocol/language-crucible) | Benchmark cross-linguaggio e corpus di riferimento |
| [Keyword Rosetta](https://github.com/squid-protocol/keyword-rosetta) | Corpus di controllo con parole chiave piantate in 50 linguaggi e report sui bias |
| [Output grezzo](https://github.com/squid-protocol/gitgalaxy-raw-output) | Scansioni non modificate di repository reali |
| [Esempi COBOL → Java](https://github.com/squid-protocol/cobol_to_java_examples) | 10 repository COBOL tradotti automaticamente in architetture Spring Boot compilabili (`mvn clean compile` funziona subito) |
| [Analisi di popolazione](https://github.com/squid-protocol/gitgalaxy-population-analyses) | Analisi statistiche sulla popolazione di scansioni di output grezzo: clustering di archetipi, distribuzioni di rischio, studi sul classificatore di minacce |
| [Museo del Codice](https://squid-protocol.github.io/gitgalaxy/museum-of-code/) | Smontaggi architetturali completi di codebase reali (Apollo 11, benchmark IBM CICS) |
| [Telemetria di distribuzione](https://github.com/squid-protocol/squid-telemetry) | Metriche pubbliche di download su GitHub/GitLab/[PyPI](https://pypi.org/project/gitgalaxy/), rigenerate quotidianamente |
| [`tests/README.md`](https://gitlab.com/squid-protocol1/gitgalaxy/-/blob/main/tests/README.md) | Metodologia di regressione e golden-master |
| [`tri_comparison_ledger.json`](https://gitlab.com/squid-protocol1/gitgalaxy/-/blob/main/docs/self_scan/tri_comparison_ledger.json) | Registro di validazione delle discrepanze, una per una |
| [`manual_verification.json`](https://gitlab.com/squid-protocol1/gitgalaxy/-/blob/main/docs/self_scan/manual_verification.json) | Casi revisionati in cui la copertura del comparatore non è disponibile |
| [`how_to_investigate_a_discrepancy.md`](https://gitlab.com/squid-protocol1/gitgalaxy/-/blob/main/docs/self_scan/how_to_investigate_a_discrepancy.md) | Metodologia per le discrepanze del comparatore |
| [Visualizzatore](https://gitgalaxy.io/) | Visualizzazione locale del repository basata su browser |
------------------------------------------------------------------------
# Licenza
Copyright (c) 2026 Joe Esquibel
GitGalaxy è distribuito sotto la **PolyForm Noncommercial License 1.0.0**.
Vedi la licenza del repository per i termini completi.