dextatc/computerhistory
1
0
Fork 0
Code Actions Packages Projects Releases Wiki Activity

ai vs human try 0001

Browse Source
This commit is contained in:
dextatc
2026-07-28 17:54:22 +02:00
parent 54f115204f
commit efed783e25
1 changed files with 150 additions and 95 deletions
Download Patch File Download Diff File Expand all files Collapse all files
00_aMeta/toolz/CYOA/main.go
+150 -95
View File
@@ -4,7 +4,6 @@ import (
"encoding/json"
"flag"
"fmt"
"html/template"
"io"
"net/http"
"os"
@@ -22,7 +21,7 @@ type Choice struct {
type StoryNode struct {
ID string `json:"id"`
Title string `json:"title"`
Content template.HTML `json:"content"`
Content string `json:"content"` // Reiner String, JSON kümmert sich um das Escaping des HTMLs
Choices []Choice `json:"choices"`
IsReboot bool `json:"isReboot"`
IsEnd bool `json:"isEnd"`
@@ -38,14 +37,6 @@ type StoryGraph struct {
DeadEndNodes []string `json:"deadEndNodes"`
}
// Struct für das saubere Injezieren der Frontend-Komponenten
type TemplateContext struct {
Graph template.JS
CSS template.CSS
Logic template.JS
UI template.JS
}
var (
adocNodeRegex = regexp.MustCompile(`\[\[([a-zA-Z0-9_\-]+)\]\]`)
adocChoiceRegex = regexp.MustCompile(`<<([a-zA-Z0-9_\-]+)\s*,\s*([^>]+)>>`)
@@ -55,51 +46,123 @@ var (
)
func main() {
dirPtr := flag.String("dir", ".", "Verzeichnis mit AsciiDoc/Markdown Dateien")
outPtr := flag.String("out", "export/story.html", "Zielpfad für den Dateiexport")
tmplPtr := flag.String("tmpl", "template.html", "Pfad zur HTML Template-Datei")
servePtr := flag.Bool("serve", false, "Startet den API- & Preview-Server")
portPtr := flag.Int("port", 8080, "Port für den Server")
dirPtr := flag.String("dir", "./stories", "Verzeichnis mit AsciiDoc/Markdown Dateien")
frontendPtr := flag.String("frontend", "./frontend", "Pfad zum Verzeichnis der statischen Frontend-Dateien")
outPtr := flag.String("out", "export/story.html", "Zielpfad für den Dateiexport (Single-File HTML)")
servePtr := flag.Bool("serve", false, "Startet den API- & Preview-Server, statt zu exportieren")
portPtr := flag.Int("port", 3344, "Port für den Server")
flag.Parse()
fmt.Println("\033[1;36m=== Computer Historyz :: CYOA Engine (Modular) ===\033[0m")
fmt.Println("\033[1;36m=== Computer Historyz :: CYOA Engine ===\033[0m")
if info, err := os.Stat(*frontendPtr); os.IsNotExist(err) || !info.IsDir() {
fmt.Printf("\033[1;33m[WARNUNG]\033[0m Frontend-Verzeichnis '%s' nicht gefunden!\n", *frontendPtr)
}
if *servePtr {
startServer(*portPtr, *dirPtr, *outPtr, *tmplPtr)
startServer(*portPtr, *dirPtr, *frontendPtr)
return
}
// --- EXPORT MODUS ---
fmt.Printf("\033[1;34m[EXPORT]\033[0m Kompiliere Story-Graph via Asciidoctor aus '%s'...\n", *dirPtr)
graph := loadStoryGraphFromDir(*dirPtr)
validateGraph(graph)
outDir := filepath.Dir(*outPtr)
os.MkdirAll(outDir, 0755)
if err := generateHTMLFile(graph, *outPtr, *tmplPtr); err != nil {
fmt.Printf("\033[1;31m[FEHLER]\033[0m %v\n", err)
err := buildSingleFileExport(graph, *frontendPtr, *outPtr)
if err != nil {
fmt.Printf("\033[1;31m[FEHLER]\033[0m Build fehlgeschlagen: %v\n", err)
os.Exit(1)
}
fmt.Printf("\033[1;32m[ERFOLG]\033[0m Story modular generiert -> \033[1;33m%s\033[0m\n", *outPtr)
fmt.Printf("\033[1;32m[ERFOLG]\033[0m Single-File Story exportiert -> \033[1;33m%s\033[0m\n", *outPtr)
}
func readAsset(basePath, filename string) string {
b, err := os.ReadFile(filepath.Join(filepath.Dir(basePath), filename))
if err != nil {
return fmt.Sprintf("/* %s nicht gefunden */", filename)
func startServer(port int, watchDir string, frontendDir string) {
addr := fmt.Sprintf(":%d", port)
http.HandleFunc("/api/graph", func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Access-Control-Allow-Origin", "*")
w.Header().Set("Content-Type", "application/json")
if r.Method == http.MethodPost {
bodyBytes, err := io.ReadAll(r.Body)
if err != nil {
http.Error(w, `{"error": "Daten defekt"}`, http.StatusBadRequest)
return
}
graph := &StoryGraph{Nodes: make(map[string]*StoryNode)}
parseContent(string(bodyBytes), "API_POST_Stream", graph)
validateGraph(graph)
json.NewEncoder(w).Encode(graph)
fmt.Println("\033[1;34m[POST-API]\033[0m Story-Graph verarbeitet.")
return
}
if r.Method == http.MethodGet {
graph := loadStoryGraphFromDir(watchDir)
validateGraph(graph)
json.NewEncoder(w).Encode(graph)
}
})
fs := http.FileServer(http.Dir(frontendDir))
http.Handle("/", fs)
fmt.Printf("\n\033[1;32m[SERVER LÄUFT]\033[0m http://localhost:%d\n", port)
if err := http.ListenAndServe(addr, nil); err != nil {
fmt.Printf("\033[1;31m[FEHLER]\033[0m %v\n", err)
}
return string(b)
}
func renderAsciidoctor(text string) template.HTML {
if strings.TrimSpace(text) == "" { return "" }
func buildSingleFileExport(graph *StoryGraph, frontendDir string, outPath string) error {
indexPath := filepath.Join(frontendDir, "index.html")
htmlBytes, err := os.ReadFile(indexPath)
if err != nil {
return fmt.Errorf("konnte %s nicht lesen: %v", indexPath, err)
}
htmlStr := string(htmlBytes)
cssBytes, _ := os.ReadFile(filepath.Join(frontendDir, "style.css"))
logicBytes, _ := os.ReadFile(filepath.Join(frontendDir, "engine_logic.js"))
uiBytes, _ := os.ReadFile(filepath.Join(frontendDir, "engine_ui.js"))
graphJson, _ := json.Marshal(graph)
// CSS ersetzen
htmlStr = strings.Replace(htmlStr, `<link rel="stylesheet" href="style.css">`, fmt.Sprintf("<style>\n%s\n</style>", string(cssBytes)), 1)
// JS ersetzen
htmlStr = strings.Replace(htmlStr, `<script src="engine_logic.js"></script>`, fmt.Sprintf("<script>\n%s\n</script>", string(logicBytes)), 1)
htmlStr = strings.Replace(htmlStr, `<script src="engine_ui.js"></script>`, fmt.Sprintf("<script>\n%s\n</script>", string(uiBytes)), 1)
// JSON State in den Data-Block pressen
re := regexp.MustCompile(`(?s)<script id="story-data" type="application/json">.*?</script>`)
htmlStr = re.ReplaceAllString(htmlStr, fmt.Sprintf("<script id=\"story-data\" type=\"application/json\">\n%s\n</script>", string(graphJson)))
return os.WriteFile(outPath, []byte(htmlStr), 0644)
}
// renderAsciidoctor piped rohen AsciiDoc Text in den lokalen Container-Prozess
func renderAsciidoctor(text string) string {
if strings.TrimSpace(text) == "" {
return ""
}
cmd := exec.Command("asciidoctor", "--embedded", "-")
cmd.Stdin = strings.NewReader(text)
out, err := cmd.Output()
if err != nil {
fallback := strings.ReplaceAll(text, "\n", "<br>")
return template.HTML(fallback)
fmt.Printf("\033[1;33m[WARNUNG]\033[0m Asciidoctor Rendering fehlgeschlagen: %v\n", err)
return strings.ReplaceAll(text, "\n", "<br>")
}
return template.HTML(string(out))
return string(out)
}
func cleanBodyText(raw string) string {
@@ -121,38 +184,72 @@ func parseContent(rawContent string, sourceName string, graph *StoryGraph) {
currentBody.Reset()
}
nodeID := matches[1]
currentNode = &StoryNode{ ID: nodeID, Title: nodeID, Choices: make([]Choice, 0), FileSource: sourceName, Metadata: make(map[string]string) }
if graph.StartNodeID == "" || nodeID == "start" || nodeID == "node_start" { graph.StartNodeID = nodeID }
currentNode = &StoryNode{
ID: nodeID,
Title: nodeID,
Choices: make([]Choice, 0),
FileSource: sourceName,
Metadata: make(map[string]string),
}
if graph.StartNodeID == "" || nodeID == "start" || nodeID == "node_start" {
graph.StartNodeID = nodeID
}
continue
}
if currentNode == nil {
if strings.TrimSpace(line) != "" {
baseID := "start"
if sourceName != "API_POST_Stream" { baseID = strings.TrimSuffix(filepath.Base(sourceName), filepath.Ext(sourceName)) }
currentNode = &StoryNode{ ID: baseID, Title: baseID, Choices: make([]Choice, 0), FileSource: sourceName, Metadata: make(map[string]string) }
if graph.StartNodeID == "" { graph.StartNodeID = baseID }
} else { continue }
if sourceName != "API_POST_Stream" {
baseID = strings.TrimSuffix(filepath.Base(sourceName), filepath.Ext(sourceName))
}
currentNode = &StoryNode{
ID: baseID,
Title: baseID,
Choices: make([]Choice, 0),
FileSource: sourceName,
Metadata: make(map[string]string),
}
if graph.StartNodeID == "" {
graph.StartNodeID = baseID
}
} else {
continue
}
}
if mMatches := metaRegex.FindStringSubmatch(line); len(mMatches) > 2 {
currentNode.Metadata[strings.ToLower(mMatches[1])] = strings.TrimSpace(mMatches[2]); continue
currentNode.Metadata[strings.ToLower(mMatches[1])] = strings.TrimSpace(mMatches[2])
continue
}
if hMatches := headingRegex.FindStringSubmatch(line); len(hMatches) > 1 && currentNode.Title == currentNode.ID {
currentNode.Title = strings.TrimSpace(hMatches[1])
}
if cMatches := adocChoiceRegex.FindAllStringSubmatch(line, -1); len(cMatches) > 0 {
for _, match := range cMatches { currentNode.Choices = append(currentNode.Choices, Choice{TargetID: match[1], Text: strings.TrimSpace(match[2])}) }
for _, match := range cMatches {
currentNode.Choices = append(currentNode.Choices, Choice{TargetID: match[1], Text: strings.TrimSpace(match[2])})
}
}
if mMatches := mdChoiceRegex.FindAllStringSubmatch(line, -1); len(mMatches) > 0 {
for _, match := range mMatches { currentNode.Choices = append(currentNode.Choices, Choice{TargetID: match[2], Text: strings.TrimSpace(match[1])}) }
for _, match := range mMatches {
currentNode.Choices = append(currentNode.Choices, Choice{TargetID: match[2], Text: strings.TrimSpace(match[1])})
}
}
lowerLine := strings.ToLower(line)
if strings.Contains(lowerLine, "[reboot]") || strings.Contains(lowerLine, "speicherabbild") { currentNode.IsReboot = true }
if strings.Contains(lowerLine, "[ende]") || strings.Contains(lowerLine, "[end]") { currentNode.IsEnd = true }
if strings.Contains(lowerLine, "[reboot]") || strings.Contains(lowerLine, "speicherabbild") {
currentNode.IsReboot = true
}
if strings.Contains(lowerLine, "[ende]") || strings.Contains(lowerLine, "[end]") {
currentNode.IsEnd = true
}
currentBody.WriteString(line + "\n")
}
if currentNode != nil {
currentNode.Content = renderAsciidoctor(cleanBodyText(currentBody.String()))
graph.Nodes[currentNode.ID] = currentNode
@@ -166,7 +263,10 @@ func loadStoryGraphFromDir(rootDir string) *StoryGraph {
ext := strings.ToLower(filepath.Ext(path))
if ext != ".adoc" && ext != ".md" { return nil }
contentBytes, err := os.ReadFile(path)
if err == nil { parseContent(string(contentBytes), filepath.Base(path), graph) }
if err == nil {
relPath, _ := filepath.Rel(rootDir, path)
parseContent(string(contentBytes), relPath, graph)
}
return nil
})
return graph
@@ -178,60 +278,15 @@ func validateGraph(g *StoryGraph) {
for id, node := range g.Nodes {
for _, choice := range node.Choices {
referenced[choice.TargetID] = true
if _, exists := g.Nodes[choice.TargetID]; !exists { g.BrokenLinks = append(g.BrokenLinks, fmt.Sprintf("%s -> %s (in %s)", id, choice.TargetID, node.FileSource)) }
if _, exists := g.Nodes[choice.TargetID]; !exists {
g.BrokenLinks = append(g.BrokenLinks, fmt.Sprintf("%s -> %s (in %s)", id, choice.TargetID, node.FileSource))
}
}
if len(node.Choices) == 0 && !node.IsReboot && !node.IsEnd {
g.DeadEndNodes = append(g.DeadEndNodes, id)
}
if len(node.Choices) == 0 && !node.IsReboot && !node.IsEnd { g.DeadEndNodes = append(g.DeadEndNodes, id) }
}
for id := range g.Nodes { if !referenced[id] { g.OrphanNodes = append(g.OrphanNodes, id) } }
}
func getContext(graph *StoryGraph, tmplPath string) TemplateContext {
graphJson, _ := json.Marshal(graph)
return TemplateContext{
Graph: template.JS(graphJson),
CSS: template.CSS(readAsset(tmplPath, "style.css")),
Logic: template.JS(readAsset(tmplPath, "engine_logic.js")),
UI: template.JS(readAsset(tmplPath, "engine_ui.js")),
for id := range g.Nodes {
if !referenced[id] { g.OrphanNodes = append(g.OrphanNodes, id) }
}
}
func generateHTMLFile(g *StoryGraph, outPath string, tmplPath string) error {
tmpl, err := template.ParseFiles(tmplPath)
if err != nil { return fmt.Errorf("Template-Fehler: %v", err) }
f, err := os.Create(outPath)
if err != nil { return err }
defer f.Close()
return tmpl.Execute(f, getContext(g, tmplPath))
}
func startServer(port int, watchDir string, htmlPath string, tmplPath string) {
addr := fmt.Sprintf(":%d", port)
fmt.Printf("\n\033[1;32m[CONTAINER-API LÄUFT]\033[0m Port: %d | Nutzt Template: %s\n", port, tmplPath)
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Access-Control-Allow-Origin", "*")
if r.Method == http.MethodPost {
bodyBytes, err := io.ReadAll(r.Body)
if err != nil { http.Error(w, "Daten defekt", http.StatusBadRequest); return }
graph := &StoryGraph{Nodes: make(map[string]*StoryNode)}
parseContent(string(bodyBytes), "API_POST_Stream", graph)
validateGraph(graph)
w.Header().Set("Content-Type", "text/html; charset=utf-8")
tmpl, err := template.ParseFiles(tmplPath)
if err != nil { http.Error(w, "Template-Fehler: "+err.Error(), http.StatusInternalServerError); return }
tmpl.Execute(w, getContext(graph, tmplPath))
fmt.Println("\033[1;34m[POST-API]\033[0m Modularer Stack gerendert.")
return
}
if r.Method == http.MethodGet {
freshGraph := loadStoryGraphFromDir(watchDir)
_ = generateHTMLFile(freshGraph, htmlPath, tmplPath)
http.ServeFile(w, r, htmlPath)
}
})
http.ListenAndServe(addr, nil)
}