Architettura del Sistema

Componente Base: Lo Script Auto-Replicante

La struttura fondamentale di uno script auto-replicante prevede quattro fasi essenziali:

• Creazione del Prompt: Formulazione di istruzioni testuali che descrivono il comportamento desiderato per la generazione successiva
• Chiamata all'LLM: Invio del prompt a un modello di linguaggio (GPT, Claude, Gemini, etc.)
• Persistenza dell'Output: Salvataggio del codice generato in un file eseguibile
• Esecuzione Ricorsiva: Lancio del nuovo script, che ripeterà l'intero ciclo

Il Problema del Non-Determinismo

Gli LLM, per loro natura, introducono variabilità nelle risposte. Anche con lo stesso prompt, generazioni successive possono produrre codice differente. Questa caratteristica, che rappresenta un punto di forza in contesti creativi, diventa una sfida critica quando si cerca stabilità e prevedibilità in sistemi di automazione.

La variabilità può manifestarsi in diversi modi:

• Differenze sintattiche che mantengono la stessa logica
• Drift progressivo del comportamento nel corso delle iterazioni
• Introduzione involontaria di errori o comportamenti anomali
• Perdita graduale dell'intento originale

La Soluzione: Sistema di Monitoraggio e Controllo

Per garantire stabilità ed evitare derive incontrollate, è necessario affiancare al sistema auto-replicante un controllore esterno con le seguenti responsabilità:

Funzioni del Controllore

• Monitoraggio delle Differenze: Analisi comparativa tra generazioni successive utilizzando strumenti come diff
• Valutazione della Divergenza: Calcolo di metriche che quantifichino quanto il codice si sta discostando dall'originale
• Decisione di Intervento: Definizione di soglie oltre le quali il sistema deve essere arrestato o stabilizzato
• Logging e Tracciabilità: Mantenimento di uno storico delle generazioni per analisi post-mortem

Meccanismo di Sincronizzazione

Per permettere al controllore di analizzare ogni generazione prima della sua esecuzione, gli script auto-generati includono una pausa iniziale. Questo ritardo garantisce una "finestra di controllo" durante la quale il sistema di monitoraggio può:

• Leggere il contenuto del nuovo script
• Confrontarlo con la generazione precedente
• Decidere se permettere l'esecuzione o arrestare il processo

Implementazione Pratica in PHP

Presentiamo un'implementazione didattica che utilizza:

• PHP 5 come linguaggio di scripting
• Google Gemini come LLM per la generazione del codice
• diff di sistema per il confronto tra versioni
• Un sistema di controllo basato su soglie di divergenza

Componenti del Sistema

L'implementazione comprende tre elementi:

• Script Iniziale (generator_0.php): Il punto di partenza che avvia il processo di auto-replicazione
• Controllore (monitor.php): Il guardiano che analizza e valuta ogni nuova generazione
• File di Stato (system.state): Un registro che traccia lo stato del sistema (attivo/bloccato)

Flusso Operativo

• Il controllore viene avviato in background e monitora continuamente la directory
• Lo script iniziale viene eseguito, generando generator_1.php
• Prima dell'esecuzione, generator_1.php attende 5 secondi
• Durante questa pausa, il controllore:
  • Confronta il nuovo script con quello precedente
  • Calcola la percentuale di differenza
  • Verifica se la divergenza supera la soglia (30%)
• Se il sistema è ancora attivo, generator_1.php procede generando generator_2.php
• Il processo continua finché il controllore non rileva una divergenza eccessiva

Applicazioni Potenziali

Questa architettura, opportunamente raffinata, potrebbe trovare applicazione in:

• Automazione Adattiva: Sistemi che evolvono il proprio comportamento in base al contesto
• Test Generativi: Creazione automatica di casi di test progressivamente più complessi
• Ottimizzazione Iterativa: Raffinamento progressivo di algoritmi o configurazioni
• Prototipazione Rapida: Esplorazione automatica di varianti implementative

Considerazioni di Sicurezza

È fondamentale sottolineare che un sistema di questo tipo presenta rischi significativi se non adeguatamente controllato:

• Esecuzione di Codice Non Verificato: Ogni generazione potrebbe introdurre comportamenti dannosi
• Consumo di Risorse: Una catena illimitata può saturare CPU, memoria o storage
• Costi API: Le chiamate ripetute agli LLM possono comportare spese considerevoli
• Imprevedibilità: La natura non deterministica può generare comportamenti emergenti indesiderati

Per un utilizzo in ambienti di produzione, sarebbero necessari:

• Sandbox per l'esecuzione isolata
• Validazione formale del codice generato
• Circuit breaker con limiti massimi di iterazioni
• Audit trail completo di tutte le operazioni

Conclusione

Gli script auto-replicanti guidati da LLM rappresentano un'intersezione affascinante tra intelligenza artificiale e metaprogrammazione. Sebbene il non-determinismo intrinseco degli LLM ponga sfide significative, l'implementazione di sistemi di controllo appropriati può rendere questa tecnologia utilizzabile per automazioni innovative. L'esempio presentato, pur essendo semplificato per scopi didattici, illustra i principi fondamentali e le problematiche che emergono quando si tenta di creare sistemi software che evolvono autonomamente attraverso l'intelligenza artificiale generativa.

<?php

/*
 * SISTEMA DI SCRIPT AUTO-REPLICANTI CON LLM
 * ==========================================
 * 
 * Questo pacchetto contiene tre componenti:
 * 1. generator_0.php - Lo script iniziale
 * 2. monitor.php - Il controllore che verifica le differenze
 * 3. system.state - File di stato (creato automaticamente)
 * 
 * ISTRUZIONI PER L'USO:
 * 1. Inserisci la tua API key di Google Gemini nella variabile $apiKey
 * 2. Avvia il monitor: php monitor.php &
 * 3. Avvia il generatore: php generator_0.php
 * 4. Osserva l'esecuzione nei file di log
 */

// ============================================================================
// FILE 1: generator_0.php
// Lo script iniziale che avvia la catena auto-replicante
// ============================================================================



// CONFIGURAZIONE
$apiKey = "YOUR_GEMINI_API_KEY_HERE";  // Inserisci qui la tua chiave API
$generationNumber = 0;
$maxGenerations = 10;  // Limite di sicurezza

// Pausa iniziale per permettere al monitor di analizzare
echo "[Gen $generationNumber] Avvio tra 5 secondi...\n";
sleep(5);

// Verifica se il sistema è ancora attivo
if (file_exists('system.state')) {
    $state = trim(file_get_contents('system.state'));
    if ($state === 'BLOCKED') {
        echo "[Gen $generationNumber] Sistema bloccato dal monitor. Terminazione.\n";
        exit(1);
    }
}

echo "[Gen $generationNumber] Esecuzione in corso...\n";

// Limite di sicurezza
if ($generationNumber >= $maxGenerations) {
    echo "[Gen $generationNumber] Raggiunto limite massimo di generazioni.\n";
    file_put_contents('system.state', 'BLOCKED');
    exit(0);
}

// Costruzione del prompt per generare il prossimo script
$nextGen = $generationNumber + 1;
$prompt = "Genera uno script PHP5 che sia identico a questo template, ma con generationNumber incrementato a $nextGen.

Lo script deve:
1. Avere una pausa iniziale di 5 secondi con sleep(5)
2. Verificare il file system.state per controllare se è BLOCKED
3. Controllare che generationNumber non superi maxGenerations (10)
4. Chiamare l'API di Gemini con questo stesso prompt incrementando il numero
5. Salvare l'output in generator_$nextGen.php
6. Eseguire il file generato con exec()
7. Usare l'API key: $apiKey

Il codice deve essere valido PHP5, funzionante e ben commentato.
Mantieni la stessa struttura e logica. Non aggiungere funzionalità extra.";

// Chiamata all'API di Google Gemini
$data = array(
    'contents' => array(
        array(
            'parts' => array(
                array('text' => $prompt)
            )
        )
    ),
    'generationConfig' => array(
        'temperature' => 0.1,  // Bassa temperatura per maggiore determinismo
        'maxOutputTokens' => 2048
    )
);

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent?key=$apiKey");
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, array('Content-Type: application/json'));

$response = curl_exec($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

if ($httpCode !== 200) {
    echo "[Gen $generationNumber] Errore nella chiamata API: HTTP $httpCode\n";
    echo "Response: $response\n";
    exit(1);
}

// Parsing della risposta
$result = json_decode($response, true);

if (!isset($result['candidates'][0]['content']['parts'][0]['text'])) {
    echo "[Gen $generationNumber] Errore: risposta API malformata\n";
    exit(1);
}

$generatedCode = $result['candidates'][0]['content']['parts'][0]['text'];

// Pulizia del codice (rimozione di markdown se presente)
$generatedCode = preg_replace('/```php\s*/', '<?php', $generatedCode);
$generatedCode = preg_replace('/```\s*$/', '', $generatedCode);
$generatedCode = trim($generatedCode);

// Salvataggio del nuovo script
$nextFile = "generator_$nextGen.php";
file_put_contents($nextFile, $generatedCode);
chmod($nextFile, 0755);

echo "[Gen $generationNumber] Generato: $nextFile\n";
echo "[Gen $generationNumber] Dimensione: " . filesize($nextFile) . " bytes\n";

// Esecuzione del prossimo script
echo "[Gen $generationNumber] Lancio della prossima generazione...\n\n";
exec("php $nextFile > generation_$nextGen.log 2>&1 &");

echo "[Gen $generationNumber] Completato.\n";

?>

<?php
// ============================================================================
// FILE 2: monitor.php
// Il controllore che monitora le differenze tra generazioni
// ============================================================================



echo "=== MONITOR SISTEMA AUTO-REPLICANTE ===\n";
echo "Avvio monitoraggio...\n\n";

// Inizializzazione stato
file_put_contents('system.state', 'ACTIVE');
file_put_contents('monitor.log', "[" . date('Y-m-d H:i:s') . "] Monitor avviato\n");

$divergenceThreshold = 30.0;  // Soglia di divergenza in percentuale
$checkInterval = 2;  // Intervallo di controllo in secondi
$previousFile = null;
$generationCount = 0;

while (true) {
    sleep($checkInterval);
    
    // Cerca l'ultimo file generato
    $files = glob('generator_*.php');
    if (empty($files)) {
        continue;
    }
    
    // Ordina per numero di generazione
    usort($files, function($a, $b) {
        preg_match('/generator_(\d+)\.php/', $a, $matchA);
        preg_match('/generator_(\d+)\.php/', $b, $matchB);
        return (int)$matchA[1] - (int)$matchB[1];
    });
    
    $currentFile = end($files);
    
    // Se è un nuovo file, analizzalo
    if ($currentFile !== $previousFile && $previousFile !== null) {
        $generationCount++;
        
        echo "\n--- Analisi Generazione $generationCount ---\n";
        echo "File precedente: $previousFile\n";
        echo "File corrente: $currentFile\n";
        
        // Calcola differenze usando diff
        exec("diff -u $previousFile $currentFile | wc -l", $output);
        $diffLines = (int)$output[0];
        
        // Conta le righe totali
        $previousLines = count(file($previousFile));
        $currentLines = count(file($currentFile));
        $avgLines = ($previousLines + $currentLines) / 2;
        
        // Calcola percentuale di divergenza
        $divergence = ($avgLines > 0) ? ($diffLines / $avgLines) * 100 : 0;
        
        echo "Righe precedenti: $previousLines\n";
        echo "Righe correnti: $currentLines\n";
        echo "Righe differenti: $diffLines\n";
        echo "Divergenza: " . number_format($divergence, 2) . "%\n";
        
        // Log
        $logMessage = sprintf(
            "[%s] Gen %d: %s -> %s | Divergenza: %.2f%% | Linee diff: %d\n",
            date('Y-m-d H:i:s'),
            $generationCount,
            $previousFile,
            $currentFile,
            $divergence,
            $diffLines
        );
        file_put_contents('monitor.log', $logMessage, FILE_APPEND);
        
        // Verifica soglia
        if ($divergence > $divergenceThreshold) {
            echo "\n!!! ATTENZIONE: Divergenza eccessiva rilevata !!!\n";
            echo "Soglia: $divergenceThreshold% | Rilevata: " . number_format($divergence, 2) . "%\n";
            echo "BLOCCO DEL SISTEMA\n";
            
            file_put_contents('system.state', 'BLOCKED');
            
            $blockMessage = sprintf(
                "[%s] SISTEMA BLOCCATO - Divergenza %.2f%% supera soglia %.2f%%\n",
                date('Y-m-d H:i:s'),
                $divergence,
                $divergenceThreshold
            );
            file_put_contents('monitor.log', $blockMessage, FILE_APPEND);
            
            // Salva un diff dettagliato
            exec("diff -u $previousFile $currentFile > divergence_gen{$generationCount}.diff");
            echo "Diff salvato in: divergence_gen{$generationCount}.diff\n";
            
            break;
        } else {
            echo "Status: OK - Sistema stabile\n";
        }
    }
    
    $previousFile = $currentFile;
    
    // Verifica se il sistema è stato bloccato esternamente
    if (file_exists('system.state')) {
        $state = trim(file_get_contents('system.state'));
        if ($state === 'BLOCKED') {
            echo "\nSistema bloccato. Terminazione monitor.\n";
            break;
        }
    }
}

echo "\n=== MONITOR TERMINATO ===\n";

?>

<?php
// ============================================================================
// NOTA: Per usare questo sistema, devi separare i tre blocchi di codice
// commentati sopra in tre file distinti:
// 
// 1. Copia il contenuto del primo blocco in "generator_0.php"
// 2. Copia il contenuto del secondo blocco in "monitor.php"  
// 3. Inserisci la tua API key di Gemini in generator_0.php
// 4. Esegui: php monitor.php &
// 5. Esegui: php generator_0.php
// ============================================================================

echo "Questo file contiene il codice completo del sistema.\n";
echo "Estrai i tre componenti commentati e salvali nei rispettivi file.\n";
echo "Leggi le istruzioni all'inizio del file.\n";

?>