A universal, zero‑IF engine that transforms structured truth into actionable strategy. Garbage in, garbage out. Certified data in, certified plan out.
This engine is not a probabilistic AI. It does not guess. It does not hallucinate.
It executes deterministic logic exclusively on the input you provide.
USE CERTIFIED DATA ONLY.
Any output derived from incomplete, unverified, or manipulated data is the sole responsibility of the operator.
The engine guarantees the logical coherence of the plan, not the truthfulness of your input.
import json
import hashlib
import argparse
from datetime import datetime
from typing import Any, Dict, List
from itertools import combinations
def carica_dati_certi(percorso_file: str) -> Dict[str, Any]:
with open(percorso_file, 'r', encoding='utf-8') as f:
return json.load(f)
def trova_connessioni(dati: Dict[str, Any], obiettivo: str) -> List[Dict[str, Any]]:
intuizioni = []
entita = list(dati.keys())
for e1, e2 in combinations(entita, 2):
if isinstance(dati[e1], dict) and isinstance(dati[e2], dict):
chiavi_comuni = set(dati[e1].keys()) & set(dati[e2].keys())
for chiave in chiavi_comuni:
intuizioni.append({
"id": hashlib.sha256(f"{e1}_{e2}_{chiave}".encode()).hexdigest(),
"descrizione": f"Collegamento tra '{e1}' e '{e2}' tramite '{chiave}'.",
"ganci": [f"{e1}.{chiave} = {dati[e1][chiave]}", f"{e2}.{chiave} = {dati[e2][chiave]}"],
"prossimi_passi": [f"Approfondire la relazione tra {e1} e {e2}.", f"Verificare se {e1}.{chiave} può influenzare {e2}.{chiave}."]
})
parole_chiave = obiettivo.lower().split()
for entita in entita:
if isinstance(dati[entita], dict):
for chiave, valore in dati[entita].items():
if any(parola in str(valore).lower() for parola in parole_chiave):
intuizioni.append({
"id": hashlib.sha256(f"obiettivo_{entita}_{chiave}".encode()).hexdigest(),
"descrizione": f"L'entità '{entita}' contiene '{chiave}' che corrisponde all'obiettivo.",
"ganci": [f"{entita}.{chiave} = {valore}"],
"prossimi_passi": [f"Esplorare come usare {entita}.{chiave} per raggiungere l'obiettivo."]
})
intuizioni.sort(key=lambda x: len(x["ganci"]), reverse=True)
return intuizioni
def genera_piano(intuizioni: List[Dict[str, Any]], obiettivo: str) -> Dict[str, Any]:
if not intuizioni:
piano = {
"obiettivo": obiettivo,
"timestamp": datetime.now().isoformat(),
"stato": "Dati insufficienti.",
"passi": []
}
else:
passi_unici = set()
for intuizione in intuizioni[:5]:
for passo in intuizione["prossimi_passi"]:
passi_unici.add(passo)
piano = {
"obiettivo": obiettivo,
"timestamp": datetime.now().isoformat(),
"stato": "Piano generato.",
"passi": list(passi_unici)
}
piano_copy = {k: v for k, v in piano.items()}
firma = hashlib.sha256(json.dumps(piano_copy, sort_keys=True, ensure_ascii=False).encode()).hexdigest()
piano["firma"] = firma
return piano
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--data", required=True)
parser.add_argument("--goal", required=True)
args = parser.parse_args()
try:
dati = carica_dati_certi(args.data)
except Exception as e:
print(f"[ERRORE] {e}")
return
intuizioni = trova_connessioni(dati, args.goal)
piano = genera_piano(intuizioni, args.goal)
print("=" * 60)
print(f"OBIETTIVO: {piano['obiettivo']}\nTIMESTAMP: {piano['timestamp']}\nSTATO: {piano['stato']}")
if "firma" in piano:
print(f"FIRMA: {piano['firma']}")
print("=" * 60)
for i, passo in enumerate(piano['passi'], 1):
print(f"{i}. {passo}")
with open("piano_azione.json", "w", encoding="utf-8") as f:
json.dump(piano, f, indent=2, ensure_ascii=False)
if __name__ == "__main__":
main()