feat: inicializar sentinel autónomo con Go + HTMX

Sistema con soporte go:embed, tooltips dinámicos y Makefile optimizado.

Author: santiagourdaneta

.github/workflows/main.yml

@@ -0,0 +1,16 @@
+name: CI-CD-2026
+on: [push]
+jobs:
+  quality-gate:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Go
+        uses: actions/setup-go@v4
+        with: {go-version: '1.24'}
+      - name: Linter & Format
+        run: |
+          go fmt ./...
+          go vet ./...
+      - name: Unit Tests
+        run: go test -v ./...

.gitignore

@@ -0,0 +1,24 @@
+# Ejecutables de Go
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+decade_sentinel
+sentinel_pro
+
+# Herramientas de compilación
+bin/
+obj/
+
+# Dependencias
+vendor/
+
+# Logs y temporales
+*.log
+.tmp/
+
+# IDEs
+.vscode/
+.idea/
+*.swp

Dockerfile

@@ -0,0 +1,15 @@
+# ETAPA 1: Construcción (El taller)
+FROM golang:1.24-alpine AS builder
+WORKDIR /app
+COPY . .
+RUN go mod download
+RUN CGO_ENABLED=0 GOOS=linux go build -o main api/main.go
+
+# ETAPA 2: Ejecución (El cohete ligero)
+FROM scratch
+WORKDIR /root/
+# Solo copiamos el binario y los archivos visuales (Máxima seguridad y mínimo peso)
+COPY --from=builder /app/main .
+COPY --from=builder /app/static ./static
+EXPOSE 8080
+CMD ["./main"]

Makefile

@@ -0,0 +1,26 @@
+# Variables
+BINARY_NAME=sentinel_pro.exe
+PORT=8080
+
+.PHONY: all build run clean dev
+
+all: build run
+
+# Regla de Desarrollo: Limpia, Compila y Corre
+dev: clean build run
+
+# Compilar el motor (Go)
+build:
+	@echo "🔨 Compilando binario autónomo..."
+	go build -o $(BINARY_NAME) ./api/main.go
+
+# Encender el motor
+run:
+	@echo "🚀 Sentinel 2026 activo en http://localhost:$(PORT)"
+	./$(BINARY_NAME)
+
+# Limpiar restos (Matar proceso y borrar exe)
+clean:
+	@echo "🧹 Limpiando procesos y binarios..."
+	-taskkill //F //IM $(BINARY_NAME) //T 2>/dev/null || true
+	-rm -f $(BINARY_NAME)

README.md

@@ -0,0 +1,45 @@
+# 🛰️ Decade Sentinel 2026
+
+![Go](https://img.shields.io/badge/Go-00ADD8?style=for-the-badge&logo=go&logoColor=white)
+![HTMX](https://img.shields.io/badge/htmx-3366CC?style=for-the-badge&logo=htmx&logoColor=white)
+![License](https://img.shields.io/badge/License-MIT-green?style=for-the-badge)
+
+**Decade Sentinel** es una aplicación web autónoma y ultra-ligera que explora la evolución tecnológica entre 2016 y 2026. Construida con **Go** para el motor de backend y **HTMX** para una experiencia de usuario dinámica sin la sobrecarga de pesados frameworks de JavaScript.
+
+## 🚀 Características Clave
+- **Binario Autónomo:** Utiliza `go:embed` para incluir HTML, CSS y JS dentro del ejecutable.
+- **UX Fluida:** Tooltips dinámicos con telemetría de carga simulada mediante HTMX.
+- **Arquitectura Limpia:** Middleware de seguridad integrado (CSP, XSS Protection).
+- **Estética Cyberpunk:** Interfaz de terminal de comando optimizada para legibilidad y performance.
+
+## 🛠️ Tecnologías
+- **Backend:** Go (Golang) 1.2x
+- **Frontend:** HTMX, CSS3 (Variables y Animaciones), HTML5.
+- **Despliegue:** Makefile optimizado para entornos Windows/Linux.
+
+## 📦 Instalación y Uso
+
+1. Clona el repositorio:
+   ```bash
+   git clone [https://github.com/santiagourdaneta/decade-sentinel-2026.git](https://github.com/santiagourdaneta/decade-sentinel-2026.git)
+   cd decade-sentinel-2026
+
+2. Ejecuta el entorno de desarrollo (requiere Make):
+
+make dev
+
+3. Abre tu navegador en: http://localhost:8080
+
+🛡️ Seguridad
+
+El servidor incluye un SecurityMiddleware que implementa:
+
+Content Security Policy (CSP) restrictivo.
+
+Protección contra Sniffing de tipos (X-Content-Type-Options).
+
+Prevención de Clickjacking (X-Frame-Options).
+
+Desarrollado con ❤️ por Santiago Urdaneta
+
+#Golang #HTMX #CSS3 #JavaScript #WebDevelopment #SoftwareArchitecture #Sentinel2026 #Coding #CyberpunkUI

api/logic.go

@@ -0,0 +1,24 @@
+package main
+
+// GetHito devuelve el hito tecnológico de un año específico.
+// Esta función está aislada para poder testearla sin levantar un servidor.
+func GetHito(year int) string {
+	details := map[int]string{
+		2016: "Auge de Docker y Microservicios. .NET Core se lanza como Open Source.",
+		2017: "Publicación del paper 'Attention is All You Need'. Nace la arquitectura Transformer.",
+		2018: "Lanzamiento de React Hooks. El estándar ES2018 revoluciona JavaScript.",
+		2019: "HTTP/3 basado en QUIC empieza a estandarizarse. El Edge Computing despega.",
+		2020: "Aceleración masiva de Cloud. Apple silicon (M1) cambia la arquitectura de CPUs portátiles.",
+		2021: "Consolidación de eBPF para observabilidad. GitHub Copilot introduce la IA al desarrollo.",
+		2022: "Aparición de ChatGPT y modelos estables. La ingeniería de prompts se vuelve un rol.",
+		2023: "Boom de bases de datos vectoriales. HTMX revive el server-driven UI.",
+		2024: "IA Agentic: Los modelos ya no solo escriben, sino que ejecutan tareas complejas.",
+		2025: "Soberanía de Datos: Privacidad por diseño (GDPR 2.0) y Edge AI local.",
+		2026: "Sistemas Autónomos: El software se adapta al humano, Zero-trust real.",
+	}
+
+	if val, ok := details[year]; ok {
+		return val
+	}
+	return "Año fuera del rango de la década 2016-2026."
+}

api/logic_test.go

@@ -0,0 +1,27 @@
+package main
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestYearHitos(t *testing.T) {
+	// Definimos casos de prueba 
+	tests := []struct {
+		year int
+		want string
+	}{
+		{2016, "Auge de Docker"},
+		{2023, "HTMX"},
+		{2026, "Sistemas Autónomos"},
+	}
+
+	for _, tt := range tests {
+		t.Run(string(rune(tt.year)), func(t *testing.T) {
+			got := GetHito(tt.year)
+			if !strings.Contains(got, tt.want) {
+				t.Errorf("GetHito(%d) = %q; want it to contain %q", tt.year, got, tt.want)
+			}
+		})
+	}
+}

api/main.go

@@ -0,0 +1,93 @@
+package main
+
+import (
+	"embed"
+	"fmt"
+	"io/fs"
+	"log"
+	"log/slog"
+	"net/http"
+	"time"
+)
+
+// Base de datos de la cronología
+var details = map[string]string{
+	"2016": "Docker estandariza el envío de software. Se acaba el 'en mi máquina funciona'.",
+	"2017": "Aparece el paper 'Attention is All You Need'. Los Transformers cambian el futuro.",
+	"2018": "Serverless y Edge Computing. El código se ejecuta cerca del usuario.",
+	"2019": "Microservicios masivos. El reto es entender cómo se comunican.",
+	"2020": "La nube se vuelve el cimiento de la sociedad ante la crisis global.",
+	"2021": "GitHub Copilot: La IA empieza a escribir funciones reales.",
+	"2022": "ChatGPT y Stable Diffusion rompen la barrera técnica.",
+	"2023": "HTMX revive el Server-Driven UI. Menos complejidad, más velocidad.",
+	"2024": "Bases de datos vectoriales: La IA ahora tiene memoria a largo plazo.",
+	"2025": "GDPR 2.0 y Edge AI local. Soberanía total del dato.",
+	"2026": "Sistemas auto-curables y Zero-Trust real. El software es autónomo.",
+}
+
+func SecurityMiddleware(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("X-Frame-Options", "DENY")
+		w.Header().Set("X-Content-Type-Options", "nosniff")
+		
+		// CSP PERMISIVO PARA HTMX (Permite estilos inline y scripts de unpkg)
+		w.Header().Set("Content-Security-Policy", 
+			"default-src 'self' unpkg.com; " +
+			"style-src 'self' 'unsafe-inline' unpkg.com; " + 
+			"script-src 'self' 'unsafe-inline' unpkg.com; " +
+			"connect-src 'self';")
+		
+		next.ServeHTTP(w, r)
+	})
+}
+
+func handleYearDetails(w http.ResponseWriter, r *http.Request) {
+	// ⏳ RETRASO ARTIFICIAL: 600ms para que luzca la telemetría
+	time.Sleep(300 * time.Millisecond)
+
+	year := r.URL.Query().Get("year")
+	val, ok := details[year]
+
+	if !ok {
+		slog.Warn("🚨 INTENTO DE ACCESO A AÑO INEXISTENTE", "año", year)
+		w.WriteHeader(http.StatusNotFound)
+		fmt.Fprintf(w, "<div class='error-alert'>⚠️ ERROR: Año %s fuera de los registros.</div>", year)
+		return
+	}
+
+	w.Header().Set("Content-Type", "text/html")
+	fmt.Fprintf(w, "<strong>> Detalles:  %s:</strong><br>%s", year, val)
+}
+
+//go:embed all:static
+var staticFiles embed.FS
+
+func main() {
+	mux := http.NewServeMux()
+
+	// Servir CSS, JS e Imágenes 
+	staticContent, _ := fs.Sub(staticFiles, "static")
+	mux.Handle("/css/", http.FileServer(http.FS(staticContent)))
+	mux.Handle("/js/", http.FileServer(http.FS(staticContent)))
+	mux.Handle("/img/", http.FileServer(http.FS(staticContent)))
+
+	// Ruta principal
+	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/" {
+			http.NotFound(w, r)
+			return
+		}
+		index, err := staticFiles.ReadFile("static/index.html")
+		if err != nil {
+			http.Error(w, "Error interno: index.html no encontrado en embed", 500)
+			return
+		}
+		w.Header().Set("Content-Type", "text/html; charset=utf-8")
+		w.Write(index)
+	})
+
+	mux.HandleFunc("/api/details", handleYearDetails)
+
+	fmt.Println("🚀 Sentinel 2026 AUTÓNOMO: http://localhost:8080")
+	log.Fatal(http.ListenAndServe(":8080", SecurityMiddleware(mux)))
+}

api/main_test.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func TestSecurityHeaders(t *testing.T) {
+	// Usamos un grabador de respuestas para no necesitar el servidor encendido
+	handler := SecurityMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}))
+	req := httptest.NewRequest("GET", "http://localhost:8080", nil)
+	w := httptest.NewRecorder()
+
+	handler.ServeHTTP(w, req)
+
+	resp := w.Result()
+	if resp.Header.Get("X-Frame-Options") != "DENY" {
+		t.Error("Seguridad Crítica: X-Frame-Options ausente")
+	}
+}