mythos-code 1.5.0 → 1.7.1

package/bin/mythos.js

@@ -20,6 +20,7 @@ const TOOL_PROMPT = [
   '<tool>{"name":"ls","path":"."}</tool>  Ordner auflisten',
   '<tool>{"name":"websearch","query":"..."}</tool>  Im Internet suchen (z. B. Doku, Fehlermeldungen)',
   '<tool>{"name":"fetch","url":"https://..."}</tool>  Webseite als Text lesen',
+  '<tool>{"name":"todo","items":[{"text":"Schritt","done":false}]}</tool>  Aufgabenliste anlegen/aktualisieren (bei größeren Aufgaben zuerst planen, dann Punkte abhaken; immer die komplette Liste senden)',
   "Nach jedem Werkzeug bekommst du das Ergebnis. Suche erst, statt Dateien blind zu lesen. Ändere bestehende Dateien mit edit statt write.",
   "Arbeite Schritt für Schritt, bis die Aufgabe erledigt ist, dann antworte normal ohne <tool> (Markdown erlaubt).",
 ].join("\n");
@@ -47,9 +48,15 @@ const memoryPrompt = (mem) => mem
   ? "\n\nProjekt-Gedächtnis (" + MEMORY_FILE + " im Projektordner – halte dich daran, ergänze es bei wichtigen neuen Erkenntnissen per edit):\n" + mem
   : "";
 const goalPrompt = (goal) => goal
-  ? "\n\nZIEL (/goal): " + goal + "\nDer Nutzer ist nicht am Rechner. Arbeite komplett selbstständig, ohne Rückfragen, bis das Ziel vollständig erreicht und überprüft ist. Erst dann schreibe in deiner letzten Antwort eine eigene Zeile: ZIEL ERREICHT"
+  ? "\n\nZIEL (/goal): " + goal +
+    "\nDer Auftraggeber ist NICHT am Rechner und liest erst viel später mit, was hier im Chat passiert ist – frage ihn nichts, er kann nicht antworten. Behandle jede Entscheidung, jede Rückfrage und jedes Hindernis als etwas, das du selbst lösen musst:" +
+    "\n- Gib bei Fehlern NIEMALS auf. Ein fehlgeschlagener Befehl, eine fehlende Abhängigkeit, ein kaputter Build sind Aufgaben, keine Endstationen: lies die Fehlermeldung genau, versuche eine andere Vorgehensweise, installiere Fehlendes selbst (z. B. per npm/pip/winget), nutze bei Bedarf websearch/fetch um die Lösung nachzuschlagen, und probiere es erneut. Erst wenn du wirklich mehrere grundverschiedene Ansätze erfolglos versucht hast, notierst du das Problem knapp und machst mit dem Rest der Aufgabe weiter." +
+    "\n- Triff sinnvolle Annahmen statt zu fragen, und schreib kurz dazu, welche Annahme du getroffen hast." +
+    "\n- Teile deinen Fortschritt normal im Chat mit (was du tust und warum), aber warte nicht auf eine Antwort." +
+    "\n- Das ist eine große, langlaufende Aufgabe: Plane für 1 bis 5 Stunden durchgehende Arbeit in vielen kleinen Schritten, nicht für ein paar Minuten. Höre nicht zu früh auf – arbeite lieber zu gründlich als zu knapp." +
+    "\nArbeite komplett selbstständig weiter, bis das Ziel vollständig erreicht und überprüft ist. Erst dann schreibe in deiner letzten Antwort eine eigene Zeile: ZIEL ERREICHT"
   : "";
-const GOAL_NUDGE = "Das Ziel ist noch nicht als erreicht gemeldet. Arbeite selbstständig weiter, ohne Rückfragen. Wenn es wirklich vollständig erledigt und geprüft ist, schreibe ZIEL ERREICHT.";
+const GOAL_NUDGE = "Das Ziel ist noch nicht als erreicht gemeldet. Der Auftraggeber ist nicht da – gib bei Problemen nicht auf, sondern versuche einen anderen Weg, nutze websearch/fetch für Lösungen und arbeite selbstständig weiter, ohne Rückfragen. Wenn es wirklich vollständig erledigt und geprüft ist, schreibe ZIEL ERREICHT.";
 const SUMMARY_PROMPT = "Fasse jetzt kurz auf Deutsch zusammen, OHNE Werkzeuge:\n**Geändert:** welche Dateien und was\n**Geklappt:** was funktioniert (und wie geprüft)\n**Offen:** was noch fehlt oder beachtet werden muss\nMaximal 12 Zeilen.";
 
 const SKIP_DIRS = new Set(["node_modules", ".git", "dist", "build", ".next", "out", "coverage", ".cache", "vendor", "__pycache__", ".venv", "venv", "target"]);
@@ -170,9 +177,46 @@ function searchFiles(root, pattern, glob, max = 200) {
   return hits.join("\n") + (hits.length >= max ? "\n… (mehr als " + max + " Treffer – Suche eingrenzen)" : "");
 }
 
+// ---------- Sicherheitsnetz für Befehle ----------
+// Diese Befehle fragen IMMER nach (auch mit Vollzugriff) und werden im /goal-Modus blockiert,
+// weil dann niemand da ist, der sie bestätigen könnte.
+const DANGER = [
+  [/\brm\s+-[a-z]*(?:rf|fr)[a-z]*\s+(?:--no-preserve-root\s+)?(?:\/|~|\*|\$HOME|%USERPROFILE%)(?:\s|$)/i, "löscht rekursiv ein System- oder Home-Verzeichnis"],
+  [/\bformat(?:\.com)?\s+[a-z]:/i, "formatiert ein Laufwerk"],
+  [/\b(?:rd|rmdir)\s+\/s\b[^&|;]*\b[a-z]:\\?\s*(?:$|[&|;])/i, "löscht ein ganzes Laufwerk"],
+  [/\b(?:del|erase)\b[^&|;]*\/s\b[^&|;]*\b[a-z]:\\\*?\s*(?:$|[&|;])/i, "löscht ein ganzes Laufwerk"],
+  [/Remove-Item\b[^|;]*-Recurse[^|;]*\s["']?[a-z]:\\?["']?(?:\s|$|;)/i, "löscht rekursiv ein ganzes Laufwerk"],
+  [/\bgit\s+push\b[^;&|]*\s(?:--force(?:-with-lease)?|-f)\b/i, "überschreibt die Git-Historie auf dem Server (Force-Push)"],
+  [/\bgit\s+reset\s+--hard\b|\bgit\s+clean\s+-[a-z]*f/i, "verwirft lokale Änderungen unwiderruflich"],
+  [/\b(?:shutdown|restart-computer|stop-computer)\b/i, "fährt den PC herunter oder startet ihn neu"],
+  [/\breg(?:\.exe)?\s+delete\b|Remove-Item(?:Property)?\b[^|;]*\bHK(?:LM|CU):/i, "löscht Einträge in der Windows-Registry"],
+  [/\b(?:curl|wget|iwr|irm|invoke-webrequest|invoke-restmethod)\b[^|]*\|\s*(?:sh|bash|zsh|iex|invoke-expression|powershell|pwsh)\b/i, "lädt ein Skript aus dem Internet und führt es sofort aus"],
+  [/\bmkfs(?:\.\w+)?\b|\bdd\s+[^|;]*\bof=\/dev\//i, "überschreibt ein Laufwerk"],
+  [/:\(\)\s*\{\s*:\|:&\s*\};:/, "startet eine Fork-Bombe"],
+  [/\b(?:npm|pnpm|yarn)\s+publish\b|\bgh\s+release\s+create\b|\bgh\s+repo\s+delete\b/i, "veröffentlicht oder löscht etwas öffentlich"],
+  [/\b(?:Set-MpPreference|netsh\s+advfirewall\s+set)\b/i, "ändert Windows-Sicherheitseinstellungen (Virenschutz/Firewall)"],
+];
+/** Grund, warum ein Befehl gefährlich ist, oder null. */
+function dangerCheck(cmd) {
+  const c = String(cmd || "");
+  for (const [re, why] of DANGER) if (re.test(c)) return why;
+  return null;
+}
+
+/** Liegt `p` (relativ zu root) innerhalb des Projektordners? */
+function insideRoot(root, p) {
+  const r = path.relative(path.resolve(root), path.resolve(root, p || "."));
+  return !(r.startsWith("..") || path.isAbsolute(r));
+}
+
 /** read/write/edit/search/ls ausführen. `run` macht jede Oberfläche selbst (Live-Ausgabe). */
 function fileTool(t, root) {
   const P = (p) => path.resolve(root, p || ".");
+  // Schreiben nur innerhalb des Projekts – und nie in Gits interne Dateien.
+  if (t.name === "write" || t.name === "edit") {
+    if (!insideRoot(root, t.path)) return { result: "FEHLER: Schreiben außerhalb des Projektordners ist gesperrt (" + t.path + "). Arbeite nur mit Dateien im Projekt." };
+    if (/^\.git(?:[\\/]|$)/.test(path.relative(path.resolve(root), P(t.path)))) return { result: "FEHLER: Gits interne Dateien (.git/) werden nicht direkt bearbeitet – nutze git-Befehle." };
+  }
   try {
     if (t.name === "read") {
       const c = readText(P(t.path));
@@ -251,6 +295,84 @@ async function webTool(t) {
 }
 const isWebTool = (t) => t.name === "fetch" || t.name === "websearch";
 
+// ---------- Aufgabenliste (todo) ----------
+/** Werkzeug-Eingabe prüfen → saubere Liste [{ text, done }]. */
+function normalizeTodos(t) {
+  const items = Array.isArray(t && t.items) ? t.items : [];
+  return items.slice(0, 40).map((x) => (typeof x === "string" ? { text: x, done: false } : { text: String((x && x.text) || "").slice(0, 200), done: !!(x && x.done) })).filter((x) => x.text);
+}
+const todoSummary = (items) => "Aufgabenliste aktualisiert (" + items.filter((x) => x.done).length + "/" + items.length + " erledigt).";
+
+// ---------- Eigene Befehle: .mythos/commands/<name>.md ----------
+// Erste Zeile = Beschreibung (optional mit "# "), Rest = Anweisung an Mythos. $ARGUMENTS wird ersetzt.
+function loadCommands(dirs) {
+  const out = new Map();
+  for (const dir of dirs) {
+    let names = [];
+    try { names = fs.readdirSync(dir).filter((f) => /\.md$/i.test(f)); } catch { continue; }
+    for (const f of names) {
+      const text = readText(path.join(dir, f));
+      if (!text || !text.trim()) continue;
+      const name = f.replace(/\.md$/i, "").toLowerCase().replace(/[^a-z0-9äöüß_-]/g, "-");
+      const lines = text.replace(/\r\n/g, "\n").split("\n");
+      const desc = lines[0].replace(/^#+\s*/, "").trim().slice(0, 100);
+      out.set(name, { name: "/" + name, desc: desc || "Eigener Befehl", body: text.trim(), file: path.join(dir, f) });
+    }
+  }
+  return [...out.values()];
+}
+const fillCommand = (cmd, args) => (cmd.body.includes("$ARGUMENTS") ? cmd.body.split("$ARGUMENTS").join(args || "") : cmd.body + (args ? "\n\n" + args : ""));
+const COMMAND_TEMPLATE = "# Tests schreiben für eine Datei\nSchreibe gründliche Tests für $ARGUMENTS.\nNutze das Test-Framework, das im Projekt schon verwendet wird, und führe die Tests am Ende aus.\n";
+
+// ---------- Code-Review ----------
+const REVIEW_PROMPT = "Führe ein gründliches Code-Review der folgenden Änderungen durch. ÄNDERE KEINE DATEIEN – nur lesen und bewerten.\n" +
+  "Gliedere die Antwort so:\n**🐞 Fehler** (echte Bugs, mit Datei:Zeile)\n**⚠️ Risiken** (Sicherheit, Randfälle, Performance)\n**💡 Verbesserungen** (Lesbarkeit, Vereinfachung)\n**✅ Gut gelöst**\n" +
+  "Wenn eine Kategorie leer ist, schreib „nichts gefunden“. Sei konkret, keine allgemeinen Floskeln.";
+
+// ---------- Projektstatistik ----------
+const LANG = { js: "JavaScript", mjs: "JavaScript", cjs: "JavaScript", jsx: "JavaScript (JSX)", ts: "TypeScript", tsx: "TypeScript (TSX)", py: "Python", java: "Java", kt: "Kotlin", cs: "C#", cpp: "C++", cc: "C++", c: "C", h: "C/C++ Header", go: "Go", rs: "Rust", rb: "Ruby", php: "PHP", swift: "Swift", html: "HTML", css: "CSS", scss: "SCSS", vue: "Vue", svelte: "Svelte", json: "JSON", md: "Markdown", yml: "YAML", yaml: "YAML", sql: "SQL", sh: "Shell", ps1: "PowerShell", bat: "Batch", lua: "Lua", dart: "Dart", xml: "XML", toml: "TOML" };
+function projectStats(root) {
+  const byLang = new Map(), big = [];
+  let files = 0, lines = 0, bytes = 0, skipped = 0;
+  const walk = (dir) => {
+    let entries; try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      if (files > 30000) return;
+      const full = path.join(dir, e.name);
+      if (e.isDirectory()) { if (!SKIP_DIRS.has(e.name)) walk(full); continue; }
+      const ext = path.extname(e.name).slice(1).toLowerCase(), lang = LANG[ext];
+      if (!lang) { skipped++; continue; }
+      let st; try { st = fs.statSync(full); } catch { continue; }
+      if (st.size > 2e6) { skipped++; continue; }
+      const text = readText(full); if (text == null) continue;
+      const n = text ? text.split("\n").length : 0;
+      files++; lines += n; bytes += st.size;
+      const l = byLang.get(lang) || { files: 0, lines: 0 }; l.files++; l.lines += n; byLang.set(lang, l);
+      big.push({ file: path.relative(root, full).split(path.sep).join("/"), lines: n });
+    }
+  };
+  walk(root);
+  big.sort((a, b) => b.lines - a.lines);
+  const langs = [...byLang.entries()].sort((a, b) => b[1].lines - a[1].lines);
+  const fmt = (n) => n.toLocaleString("de-DE");
+  let md = "### 📊 Projektstatistik: " + path.basename(root) + "\n\n";
+  md += "**" + fmt(files) + " Code-Dateien · " + fmt(lines) + " Zeilen · " + (bytes / 1024 / 1024).toFixed(1) + " MB**" + (skipped ? " (" + fmt(skipped) + " andere Dateien übersprungen)" : "") + "\n\n";
+  if (langs.length) {
+    md += "| Sprache | Dateien | Zeilen | Anteil |\n|---|---:|---:|---:|\n";
+    md += langs.slice(0, 12).map(([name, v]) => "| " + name + " | " + fmt(v.files) + " | " + fmt(v.lines) + " | " + Math.round((v.lines / Math.max(1, lines)) * 100) + " % |").join("\n") + "\n\n";
+  }
+  if (big.length) md += "**Größte Dateien:**\n" + big.slice(0, 5).map((b) => "- `" + b.file + "` – " + fmt(b.lines) + " Zeilen").join("\n") + "\n";
+  return md;
+}
+
+// ---------- Chat als Markdown ----------
+function chatToMarkdown(title, messages) {
+  const date = new Date().toLocaleString("de-DE");
+  let md = "# " + (title || "Mythos-Chat") + "\n\n_Exportiert aus Mythos Code am " + date + "_\n\n---\n\n";
+  for (const m of messages) md += (m.role === "user" ? "## 🧑 Du\n\n" : m.role === "tool" ? "#### ⚙ " : "## ✦ Mythos\n\n") + String(m.text || "").trim() + "\n\n";
+  return md;
+}
+
 function readMemory(root) { const t = readText(path.join(root, MEMORY_FILE)); return t ? t.slice(0, 8000) : ""; }
 function addMemory(root, text) {
   const f = path.join(root, MEMORY_FILE);
@@ -281,7 +403,8 @@ const C = { c: "\x1b[36m", g: "\x1b[32m", y: "\x1b[33m", r: "\x1b[31m", m: "\x1b
 const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
 const ask = (q) => new Promise((r) => rl.question(q, r));
 const load = () => { try { return JSON.parse(fs.readFileSync(CFG, "utf8")); } catch { return {}; } };
-const save = (c) => fs.writeFileSync(CFG, JSON.stringify(c, null, 2));
+// Konfiguration (mit API-Schlüssel) nur für den eigenen Benutzer lesbar.
+const save = (c) => { fs.writeFileSync(CFG, JSON.stringify(c, null, 2), { mode: 0o600 }); try { fs.chmodSync(CFG, 0o600); } catch { /* Windows: Benutzerordner ist ohnehin privat */ } };
 let cfg = load();
 let autoYes = process.argv.includes("--yes");
 let goal = "";
@@ -352,6 +475,12 @@ rl.on("SIGINT", () => {
 function mdLine(line, st) {
   if (/^\s*```/.test(line)) { st.code = !st.code; return C.d + (st.code ? "┌─ " + line.trim().slice(3) : "└─") + C.x; }
   if (st.code) return C.c + "│ " + line + C.x;
+  // Markdown-Tabellen: Trennzeile als Linie, Zellen als ausgerichtete Spalten.
+  if (/^\s*\|.*\|\s*$/.test(line)) {
+    if (/^\s*\|[\s:|-]+\|\s*$/.test(line)) return C.d + "  " + "─".repeat(52) + C.x;
+    const cells = line.trim().replace(/^\||\|$/g, "").split("|").map((c) => c.trim().replace(/\*\*(.+?)\*\*/g, "$1"));
+    return "  " + cells.map((c, i) => (i === 0 ? c.padEnd(22) : c.padStart(9))).join(" ");
+  }
   const h = line.match(/^(#{1,6})\s+(.*)/);
   if (h) return C.b + C.m + h[2] + C.x;
   return line
@@ -471,6 +600,13 @@ function runLive(cmd) {
 }
 
 async function runTool(t) {
+  if (t.name === "todo") {
+    const items = normalizeTodos(t);
+    if (!items.length) return 'FEHLER: "items" fehlt – sende die komplette Liste.';
+    const done = items.filter((x) => x.done).length;
+    say(C.c + C.b + "📋 Aufgabenliste " + done + "/" + items.length + C.x + "\n" + items.map((x) => (x.done ? C.g + "  ☑ " + C.d : "  ☐ ") + x.text + C.x).join("\n"));
+    return todoSummary(items);
+  }
   const label = t.name === "run" ? "run " + t.cmd
     : t.name === "search" ? "search /" + t.pattern + "/" + (t.glob ? " " + t.glob : "")
     : t.name === "write" ? "write " + t.path + " (" + String(t.content || "").length + " Zeichen)"
@@ -478,7 +614,17 @@ async function runTool(t) {
     : t.name === "fetch" ? "fetch " + t.url
     : t.name + " " + (t.path || "");
   say(C.y + "⚙  " + label + C.x);
-  if ((t.name === "run" || t.name === "write" || t.name === "edit") && !autoYes) {
+  // Sicherheitsnetz: gefährliche Befehle fragen immer nach (auch mit --yes) und werden bei /goal blockiert.
+  const why = t.name === "run" ? dangerCheck(t.cmd) : null;
+  if (why) {
+    say(C.r + "🛡 Sicherheitsnetz: dieser Befehl " + why + "." + C.x);
+    if (goal) return "BLOCKIERT vom Sicherheitsnetz: Der Befehl " + why + ". Der Nutzer ist nicht da und kann das nicht bestätigen – finde einen sichereren Weg ohne diesen Befehl.";
+    stopTick();
+    const a = (await ask(C.r + "   Wirklich ausführen? [j/N] " + C.x)).trim().toLowerCase();
+    startTick();
+    if (a !== "j" && a !== "y") return "Vom Nutzer abgelehnt (Sicherheitsnetz). Finde einen sichereren Weg.";
+  }
+  if ((t.name === "run" || t.name === "write" || t.name === "edit") && !autoYes && !why) {
     stopTick();
     const a = (await ask(C.d + "   Erlauben? [j/N/a=immer] " + C.x)).trim().toLowerCase();
     startTick();
@@ -497,7 +643,7 @@ async function runTool(t) {
 
 // ---------- Eine Aufgabe (auch /goal) ----------
 async function turnInner(history) {
-  const max = goal ? 200 : 40;
+  const max = goal ? 4000 : 40;
   let nudges = 0;
   for (let i = 0; i < max && !stopped; i++) {
     const pr = streamPrinter();
@@ -508,7 +654,7 @@ async function turnInner(history) {
     const m = out.match(/<tool>([\s\S]*?)<\/tool>/);
     if (!m) {
       if (!goal || /ZIEL ERREICHT/.test(out)) return goal ? "reached" : "done";
-      if (++nudges > 5) { say(C.y + "🎯 Mythos kommt beim Ziel nicht weiter – schau es dir bitte an (/weiter macht weiter)." + C.x); return "stuck"; }
+      if (++nudges > 40) { say(C.y + "🎯 Mythos kommt beim Ziel nicht weiter – schau es dir bitte an (/weiter macht weiter)." + C.x); return "stuck"; }
       history.push({ role: "user", content: GOAL_NUDGE });
       continue;
     }
@@ -612,9 +758,51 @@ const HELP = [
   ["/modell [name]", "Modell anzeigen oder wechseln"],
   ["/tokens", "Geschätzten Token-Verbrauch dieser Sitzung anzeigen"],
   ["/clear", "Verlauf leeren"],
+  ["/review [schwerpunkt]", "Code-Review der Git-Änderungen (ändert nichts)"],
+  ["/pr [branch]", "Branch pushen und Pull Request erstellen"],
+  ["/stats", "Projektstatistik: Dateien, Zeilen, Sprachen"],
+  ["/export [datei]", "Chat als Markdown-Datei speichern"],
+  ["/kompakt", "Langen Chat zusammenfassen und Tokens sparen"],
+  ["@pfad/datei", "Datei in der Nachricht erwähnen – ihr Inhalt geht mit"],
+  ["/befehle", "Eigene Befehle (.mythos/commands/*.md) anzeigen"],
   ["/exit", "Beenden"],
 ];
 
+/** @pfad in der Eingabe → Dateien im Projekt, die es gibt (max. 8, je 60.000 Zeichen). */
+function mentionedFiles(text) {
+  const paths = [...new Set([...text.matchAll(/(?:^|\s)@([^\s@]+)/g)].map((m) => m[1].replace(/[.,;:!?)]+$/, "")))].slice(0, 8);
+  const out = [];
+  for (const p of paths) {
+    const full = path.resolve(ROOT, p);
+    if (path.relative(ROOT, full).startsWith("..")) continue;
+    try { if (fs.statSync(full).isFile()) { const c = readText(full); if (c != null && !c.includes("\u0000")) out.push({ name: p, content: c.slice(0, 60000) }); } } catch { /* gibt es nicht */ }
+  }
+  return out;
+}
+const COMMAND_DIRS = [path.join(os.homedir(), ".mythos", "commands"), path.join(ROOT, ".mythos", "commands")];
+const mdLines = (md) => { const st = { code: false }; return md.split("\n").map((l) => mdLine(l, st)).join("\n"); };
+async function pullRequest(name) {
+  const head = git(["rev-parse", "--abbrev-ref", "HEAD"]);
+  if (!head.ok) return console.log(C.r + "Kein Git-Repository." + C.x + "\n");
+  if (git(["status", "--porcelain"]).out.trim()) return console.log(C.y + "Es gibt noch nicht committete Änderungen – erst /commit, dann /pr." + C.x + "\n");
+  if (!git(["remote", "get-url", "origin"]).out.trim()) return console.log(C.y + "Kein Remote „origin“ eingerichtet – verbinde das Projekt zuerst mit GitHub (git remote add origin <url>)." + C.x + "\n");
+  let branch = head.out.trim();
+  if (!autoYes && !/^[jy]/i.test((await ask(C.d + "Branch pushen und Pull Request erstellen? [j/N] " + C.x)).trim())) return console.log("Abgebrochen.\n");
+  if (/^(main|master)$/.test(branch)) {
+    branch = name ? name.replace(/\s+/g, "-") : "mythos/" + new Date().toISOString().slice(0, 16).replace(/[-:T]/g, "");
+    const co = git(["checkout", "-b", branch]); if (!co.ok) return console.log(C.r + co.out + C.x);
+  }
+  const push = git(["push", "-u", "origin", branch]); if (!push.ok) return console.log(C.r + push.out.trim() + C.x + "\n");
+  try { const out = execFileSync("gh", ["pr", "create", "--fill"], { cwd: ROOT, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }); return console.log(C.g + "🔀 " + out.trim() + C.x + "\n"); }
+  catch (e) {
+    const m = git(["remote", "get-url", "origin"]).out.trim().match(/github\.com[:/](.+?)(?:\.git)?$/);
+    if (!m) return console.log(C.r + ((e.stderr || "") + "" || "Kein GitHub-Remote gefunden.") + C.x + "\n");
+    const url = "https://github.com/" + m[1] + "/compare/" + branch + "?expand=1";
+    openBrowser(url);
+    return console.log(C.g + "🔀 Branch „" + branch + "“ gepusht. PR-Seite im Browser: " + url + C.x + (e.code === "ENOENT" ? C.d + "\n   (Mit der GitHub-CLI „gh“ würde der PR direkt erstellt.)" + C.x : "") + "\n");
+  }
+}
+
 async function command(q, history) {
   const cmd = q.split(/\s+/)[0].toLowerCase(), arg = q.slice(cmd.length).trim();
   if (cmd === "/hilfe" || cmd === "/help") return console.log(HELP.map(([c, d]) => "  " + C.c + c.padEnd(22) + C.x + d).join("\n") + "\n");
@@ -652,6 +840,44 @@ async function command(q, history) {
   }
   if (cmd === "/tokens") return console.log("≈ " + fmtTokens(tokens.in) + " Eingabe + " + fmtTokens(tokens.out) + " Ausgabe = " + fmtTokens(tokens.in + tokens.out) + " Tokens (geschätzt)\n");
   if (cmd === "/vollzugriff") { autoYes = !/^(aus|off)$/i.test(arg); return console.log(autoYes ? "Vollzugriff an.\n" : "Vollzugriff aus – Mythos fragt vor Befehlen nach.\n"); }
+  if (cmd === "/review") {
+    const st = git(["status", "--porcelain"]);
+    if (!st.ok) return console.log(C.r + "Kein Git-Repository." + C.x + "\n");
+    const diff = (git(["diff", "HEAD"]).out || git(["diff"]).out).trim();
+    if (!diff && !st.out.trim()) return console.log("🔍 Keine Änderungen – nichts zu prüfen.\n");
+    return turn(history, REVIEW_PROMPT + (arg ? "\n\nBesonders beachten: " + arg : "") + "\n\n" + st.out + "\n```diff\n" + diff.slice(0, 60000) + "\n```");
+  }
+  if (cmd === "/pr") return pullRequest(arg);
+  if (cmd === "/kompakt") {
+    if (history.length < 4) return console.log("🗜 Der Chat ist noch kurz – Komprimieren lohnt sich erst später.\n");
+    const before = Math.ceil(history.reduce((a, m) => a + String(m.content).length, 0) / 4);
+    if (before < 1500) return console.log("🗜 Der Verlauf hat erst ≈ " + fmtTokens(before) + " Tokens – Komprimieren lohnt sich ab etwa 1,5k.\n");
+    const transcript = history.map((m) => (m.role === "user" ? "NUTZER/WERKZEUG: " : "MYTHOS: ") + String(m.content).slice(0, 3000)).join("\n\n").slice(-60000);
+    process.stdout.write(C.d + "🗜 Fasse den Chat zusammen…" + C.x);
+    stopped = false;
+    let sum = "";
+    try {
+      sum = (await call([{ role: "user", content: "Fasse den bisherigen Verlauf dieses Coding-Chats so zusammen, dass ein Agent nahtlos weiterarbeiten kann: **Ziel**, **Stand**, **Wichtige Dateien & Entscheidungen**, **Offene Punkte**. Maximal 25 Zeilen, ohne Werkzeuge.\n\nVERLAUF:\n" + transcript }]))
+        .replace(/<tool>[\s\S]*?<\/tool>/g, "").trim();
+    } catch (e) { clearLine(); return console.log(C.r + "⚠ " + e.message + C.x + "\n"); }
+    clearLine();
+    history.length = 0;
+    history.push({ role: "user", content: "Zusammenfassung des bisherigen Chats (komprimiert):\n\n" + sum }, { role: "assistant", content: "Verstanden – ich arbeite auf Basis dieser Zusammenfassung weiter." });
+    return console.log(mdLines(sum) + "\n" + C.g + "🗜 Komprimiert: ≈ " + fmtTokens(before) + " → ≈ " + fmtTokens(Math.ceil(sum.length / 4)) + " Tokens" + C.x + "\n");
+  }
+  if (cmd === "/stats") { const b = gitBranch(); return console.log(mdLines(projectStats(ROOT) + (b ? "\n**Git:** Branch `" + b + "`" : "")) + "\n"); }
+  if (cmd === "/export") {
+    const file = path.resolve(ROOT, arg || "mythos-chat-" + new Date().toISOString().slice(0, 16).replace(/[:T]/g, "-") + ".md");
+    const msgs = history.map((m) => ({ role: /^Werkzeug-Ergebnis/.test(m.content) ? "tool" : m.role, text: String(m.content).replace(/<tool>[\s\S]*?<\/tool>/g, "").slice(0, 20000) })).filter((m) => m.text.trim());
+    fs.writeFileSync(file, chatToMarkdown("Mythos-Chat – " + path.basename(ROOT), msgs));
+    return console.log(C.g + "✓ Gespeichert: " + file + C.x + "\n");
+  }
+  if (cmd === "/befehle") {
+    const list = loadCommands(COMMAND_DIRS);
+    return console.log(list.length ? list.map((c) => "  " + C.c + c.name.padEnd(20) + C.x + c.desc).join("\n") + "\n" : "Noch keine eigenen Befehle. Leg eine Markdown-Datei in .mythos/commands/ an, z. B. tests.md → /tests.\nErste Zeile = Beschreibung, Rest = Anweisung an Mythos, $ARGUMENTS = was du dahinter schreibst.\n");
+  }
+  const own = loadCommands(COMMAND_DIRS).find((c) => c.name === cmd);
+  if (own) return turn(history, fillCommand(own, arg));
   console.log("Unbekannter Befehl: " + cmd + " – /hilfe zeigt alle Befehle.\n");
 }
 
@@ -672,7 +898,9 @@ async function main() {
     if (q.startsWith("/")) { await command(q, history); continue; }
     const { text, images } = extractImages(q);
     if (images.length) console.log(C.d + "🖼 " + images.length + " Bild(er) angehängt" + C.x);
-    await turn(history, text, images);
+    const files = mentionedFiles(text);
+    if (files.length) console.log(C.d + "📎 " + files.map((f) => f.name).join(", ") + C.x);
+    await turn(history, text + files.map((f) => "\n\n### " + f.name + "\n```\n" + f.content + "\n```").join(""), images);
   }
   rl.close();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mythos-code",
-  "version": "1.5.0",
+  "version": "1.7.1",
   "description": "Mythos Code – KI-Coding-Agent im Terminal (by Mythoscraft)",
   "bin": {
     "mythos": "bin/mythos.js",