@renoxar/koolie 1.25.0

package/.koolie/core/install_dialog.py

@@ -0,0 +1,227 @@
+#!/usr/bin/env python3
+"""
+install_dialog.py - Der Dialog hinter den Startern install.cmd und install.command.
+
+Hintergrund (D-362, CR-2026-140): Die Starter in der Wurzel des Frameworks suchen nur
+ein passendes Python und rufen dieses Skript auf. Es fragt Projektverzeichnis, Client,
+Overlay-Muster und Lieferumfang ab und ruft danach genau einen Befehl auf:
+
+    install.py --target <projekt> [--client <name>] [--overlay <name>]
+                                  [--lieferumfang nutzung]
+    install.py --target <projekt> --update
+
+Beim Heben fragt es den Lieferumfang nicht: Es bleibt beim bisherigen (D-367), und ein
+Wechsel ist eine bewusste Handlung auf der Befehlszeile.
+
+Die Fragen stehen HIER und nicht in den Startern, weil zwei Shell-Dialekte zwei
+Dialoge waeren, die auseinanderlaufen. install.py bleibt parametergesteuert; dieses
+Skript entscheidet nichts, was install.py nicht selbst prueft - es sammelt nur die
+Parameter ein und zeigt den Befehl, bevor es ihn ausfuehrt.
+
+Die Ausgabe ist ASCII: Eine Windows-Konsole, die ein Doppelklick oeffnet, laeuft in
+ihrer eigenen Codepage, und ein Umlaut kaeme dort verstellt an. Einzige Ausnahme ist
+das Banner vor der ersten Frage (banner.py, CR-2026-165): Es waehlt seine Zeichen nach
+der Kodierung, die Python fuer die Ausgabe meldet, faellt sonst auf ASCII zurueck und
+bricht den Dialog nie ab.
+
+Aufruf (normalerweise durch einen Starter):
+
+    python .koolie/core/install_dialog.py [--no-banner] [--vorgabe <verzeichnis>]
+
+Das Banner schaltet auch KOOLIE_NO_BANNER=1 ab - der Weg fuer die Starter, die keine
+Argumente weiterreichen.
+
+--vorgabe setzt der Befehl `koolie` der Paketquellen: das Verzeichnis, in dem er
+aufgerufen wurde (D-532). Die Frage nach dem Projektverzeichnis nimmt es dann mit Enter.
+Die Starter setzen es nicht - ihr Arbeitsverzeichnis ist das Release-Archiv.
+
+Exit-Code: der von install.py; 1 bei Abbruch im Dialog.
+"""
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+import install  # noqa: E402  (liegt neben dieser Datei)
+
+VERSUCHE = 3
+
+
+class Abbruch(Exception):
+    pass
+
+
+def frage(text: str) -> str:
+    try:
+        antwort = input(text)
+    except EOFError:
+        raise Abbruch("keine Eingabe mehr")
+    if antwort.strip().lower() in ("q", "quit", "abbruch"):
+        raise Abbruch("abgebrochen")
+    return antwort.strip()
+
+
+def pfad_bereinigen(eingabe: str) -> str:
+    """Ein eingefuegter oder hineingezogener Pfad: Anfuehrungszeichen und Rand weg.
+
+    Windows setzt beim Hineinziehen doppelte Anfuehrungszeichen, das macOS-Terminal
+    maskiert Leerzeichen mit einem Rueckstrich. Beides wird hier aufgeloest.
+    """
+    p = eingabe.strip()
+    if len(p) >= 2 and p[0] == p[-1] and p[0] in "\"'":
+        p = p[1:-1]
+    if os.sep == "/":
+        p = p.replace("\\ ", " ")
+    return os.path.abspath(os.path.expanduser(p))
+
+
+def ja(text: str, vorgabe: bool) -> bool:
+    zeichen = "[J/n]" if vorgabe else "[j/N]"
+    for _ in range(VERSUCHE):
+        a = frage(f"{text} {zeichen} ").lower()
+        if not a:
+            return vorgabe
+        if a in ("j", "ja", "y", "yes"):
+            return True
+        if a in ("n", "nein", "no"):
+            return False
+        print("  Bitte j oder n.")
+    raise Abbruch("keine gueltige Antwort")
+
+
+def auswahl(text: str, optionen: list[tuple[str, str]], vorgabe: int) -> str:
+    """Nummerierte Auswahl; gibt den Wert der gewaehlten Option zurueck."""
+    print(text)
+    for i, (_wert, anzeige) in enumerate(optionen, 1):
+        mark = "  (Vorgabe)" if i == vorgabe else ""
+        print(f"  {i}. {anzeige}{mark}")
+    for _ in range(VERSUCHE):
+        a = frage(f"Nummer [{vorgabe}]: ")
+        if not a:
+            return optionen[vorgabe - 1][0]
+        if a.isdigit() and 1 <= int(a) <= len(optionen):
+            return optionen[int(a) - 1][0]
+        print(f"  Bitte eine Zahl von 1 bis {len(optionen)}.")
+    raise Abbruch("keine gueltige Auswahl")
+
+
+def projekt_erfragen(vorgabe: str = "") -> str:
+    wurzel = install.quellwurzel()
+    # Eine Vorgabe gilt nur, wenn es sie gibt und sie nicht das Framework selbst ist (D-532)
+    if vorgabe and (not os.path.isdir(vorgabe) or install._gleicher_pfad(vorgabe, wurzel)):
+        vorgabe = ""
+    text = "Projektverzeichnis (Ordner hier hineinziehen oder Pfad eingeben): "
+    if vorgabe:
+        text = f"Projektverzeichnis [Enter = {vorgabe}]: "
+    for _ in range(VERSUCHE):
+        eingabe = frage(text)
+        if not eingabe and vorgabe:
+            eingabe = vorgabe
+        if not eingabe:
+            continue
+        ziel = pfad_bereinigen(eingabe)
+        if not os.path.isdir(ziel):
+            print(f"  Das Verzeichnis gibt es nicht: {ziel}")
+            continue
+        if install._gleicher_pfad(ziel, wurzel):
+            print("  Das ist das Framework selbst. Gemeint ist das Projekt, in das "
+                  "installiert wird.")
+            continue
+        return ziel
+    raise Abbruch("kein gueltiges Projektverzeichnis")
+
+
+def befehl_bauen(ziel: str) -> list[str]:
+    argv = [sys.executable, os.path.join(HERE, "install.py"), "--target", ziel]
+    zielkern = os.path.join(ziel, *install.clientmap.CORE_REL.split("/"))
+    if os.path.isdir(zielkern):
+        stand = install.kern_version(zielkern)
+        print()
+        print(f"In diesem Projekt liegt bereits Koolie {stand} "
+              f"(Lieferumfang {install.clientmap.lieferumfang(zielkern)}, bleibt).")
+        if not ja(f"Auf {install.kern_version(HERE)} heben?", True):
+            raise Abbruch("nicht gehoben")
+        return argv + ["--update"]
+
+    clients = install.available_clients()
+    if not clients:
+        raise Abbruch("keine Client Packs gefunden")
+    print()
+    client = auswahl("Welcher KI-Client wird in diesem Projekt verwendet?",
+                     [(c, c) for c in clients],
+                     clients.index(install.DEFAULT_CLIENT) + 1
+                     if install.DEFAULT_CLIENT in clients else 1)
+    muster = [("", "keines - das Projekt beginnt mit dem leeren Overlay")]
+    for name in install.verfuegbare_muster():
+        try:
+            m = install.muster_laden(name)
+        except install.MusterFehler:
+            continue
+        muster.append((name, f"{name} {m['version']} - Vorschlaege fuer allgemeine "
+                             f"Projektwerte und Dokumente, geben nichts frei"))
+    overlay = ""
+    if len(muster) > 1:
+        print()
+        overlay = auswahl("Mit einem Overlay-Muster beginnen?", muster, 1)
+    print()
+    umfang = auswahl("Was soll im Projekt liegen?",
+                     [("voll", "der ganze Kern - mit Aenderungsantraegen, Protokollen und "
+                               "Erhebungen"),
+                      ("nutzung", "nur das zur Nutzung Noetige - ohne diese Nachweise")], 1)
+    argv += ["--client", client]
+    if overlay:
+        argv += ["--overlay", overlay]
+    if umfang != "voll":
+        argv += ["--lieferumfang", umfang]
+    return argv
+
+
+def banner_ausgeben(argv: list) -> None:
+    """Das Banner - in einer eigenen Huelle, damit selbst ein fehlendes Modul den Dialog
+    nicht aufhaelt (F-5)."""
+    try:
+        import banner
+        banner.ausgeben(argv=argv, version=install.kern_version(HERE))
+    except Exception:  # noqa: BLE001
+        pass
+
+
+def vorgabe_lesen(argv: list) -> tuple[str, list]:
+    """(--vorgabe <verzeichnis>, uebrige Argumente) - die Vorgabe des Befehls koolie (D-532)."""
+    if "--vorgabe" in argv:
+        i = argv.index("--vorgabe")
+        if i + 1 < len(argv):
+            return os.path.abspath(argv[i + 1]), argv[:i] + argv[i + 2:]
+        return "", argv[:i]
+    return "", argv
+
+
+def main(argv: list) -> int:
+    vorgabe, argv = vorgabe_lesen(argv)
+    banner_ausgeben(argv)
+    print(f"Koolie {install.kern_version(HERE)} - Installation in ein Projekt")
+    print(f"Quelle: {install.quellwurzel()}")
+    print("Abbrechen jederzeit mit q.")
+    print()
+    try:
+        ziel = projekt_erfragen(vorgabe)
+        argv = befehl_bauen(ziel)
+        print()
+        print("Ausgefuehrt wird:")
+        print("  " + subprocess.list2cmdline(argv[1:]) if os.name == "nt"
+              else "  " + " ".join(argv[1:]))
+        if not ja("Fortfahren?", True):
+            raise Abbruch("nicht bestaetigt")
+    except Abbruch as exc:
+        print(f"\nNichts installiert ({exc}).")
+        return 1
+    print()
+    sys.stdout.flush()
+    return subprocess.run(argv).returncode
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

package/.koolie/core/koexistenz.py

@@ -0,0 +1,112 @@
+# -*- coding: utf-8 -*-
+"""Fremde Agenten-Rahmenwerke im Projekt erkennen - Auskunft, keine Schranke (1.21.0, K-31).
+
+ANLASS. `K-31` fragte seit 2026-09-12, wie ein Projekt Koolie aufnimmt, das bereits ein anderes
+Agenten-Rahmenwerk fuehrt. Die Sorge war die Wurzel-Anweisung: ein Generator, der seine
+Abschnitte in `CLAUDE.md` schreibt und beim naechsten Lauf zurueckschreibt. GEMESSEN am
+2026-09-30 an zwei verbreiteten Rahmenwerken (OpenSpec 1.13.2, GitHub Spec Kit): Keines schreibt
+beim Anlegen in die Wurzel-Anweisung, keines aendert eine Datei von Koolie - in beiden
+Reihenfolgen, auch nicht mit `openspec update --force`. Beide legen ihre Skills in DIESELBE
+Ablage wie Koolie (`.claude/skills/openspec-*`, `.claude/skills/speckit-*`), dazu eine eigene
+Ablage (`openspec/`, `.specify/`).
+
+Die Reibung liegt deshalb nicht in der Wurzel-Anweisung, sondern im geteilten Namensraum:
+Der Validator prueft jeden Skill der Laufzeitablage nach den Regeln fuer Koolie-Skills und
+meldete fuer sechs OpenSpec-Skills 60 Fehler und 18 Warnungen. Die Abgrenzung nach Gegenstand
+(D-478) heisst hier: Das Projekt DEKLARIERT die fremden Skills im Overlay-Manifest
+
+    fremde_skills: openspec-, speckit-
+
+und der Validator prueft sie dann nicht mehr als Koolie-Skills - die Zuordnung zu einem Korb
+der Berechtigungsdatei (D-238) verlangt er weiter: Ein fremder Skill ist ein Werkzeug der
+Sitzung wie jeder andere.
+
+Ein Generator, der doch in die Wurzel-Anweisung schreibt, wird an seinen Markierungen erkannt
+(`<!-- NAME:START -->` ... `<!-- NAME:END -->`). 🔴 GEMESSEN am selben Tag: Dann ist KOOLIE der
+Generator, der zurueckschreibt - `install.py --update` schrieb die Wurzel-Anweisung neu, und
+der Block ging ohne Meldung verloren. Seither bricht die Aktualisierung davor ab (D-515), und
+Pruefung 111 warnt vorher; der Block zaehlt ausserdem ins Budget (Pruefung 4, `K-185`).
+"""
+from __future__ import annotations
+
+import io
+import os
+import re
+
+# Gemessen am 2026-09-30 (CR-2026-167). Ein Eintrag, der hier fehlt, faellt ueber seine
+# Markierungen oder als Skill ohne Koolie-Praefix auf - er wird nicht geraten.
+BEKANNT = (
+    {"name": "OpenSpec", "praefix": "openspec-",
+     "spuren": ("openspec/config.yaml", "openspec/project.md", ".claude/commands/opsx",
+                ".agents/skills/.openspec-target")},
+    {"name": "GitHub Spec Kit", "praefix": "speckit-",
+     "spuren": (".specify/integration.json", ".specify/memory/constitution.md")},
+)
+KOOLIE_PRAEFIX_RE = re.compile(r"^(fw|prj|role-[a-z0-9]+|tech-[a-z0-9]+)-")
+MARKE_RE = re.compile(
+    r"<!--\s*([A-Za-z][A-Za-z0-9_-]*)\s*:\s*(?:START|BEGIN)\s*-->(.*?)<!--\s*\1\s*:\s*END\s*-->",
+    re.S | re.I)
+MANIFEST_REL = ".koolie/project-overlay/overlay-manifest.yaml"
+DEKLARATION_RE = re.compile(r"^fremde_skills:[ \t]*([^#\r\n]*)", re.M)
+
+
+def _lies(pfad: str) -> str:
+    try:
+        return io.open(pfad, encoding="utf-8", errors="replace").read()
+    except OSError:
+        return ""
+
+
+def deklariert(root: str) -> list:
+    """Die Praefixe aus 'fremde_skills:' im Overlay-Manifest - leer, wenn nichts gesagt ist."""
+    m = DEKLARATION_RE.search(_lies(os.path.join(root, *MANIFEST_REL.split("/"))))
+    if not m:
+        return []
+    return [p.strip().strip("\"'") for p in m.group(1).split(",") if p.strip().strip("\"'")]
+
+
+KOOLIE_PRAEFIXE = ("fw-", "prj-", "role-", "tech-")
+
+
+def zulaessig(praefix: str) -> bool:
+    """Ein Praefix, das einen Koolie-Skill treffen koennte, nimmt nichts aus (Pruefung 111).
+
+    Sonst waere die Deklaration ein Weg, die eigenen Skills der Pruefung zu entziehen.
+    """
+    p = praefix.strip()
+    return len(p) >= 3 and not any(k.startswith(p) or p.startswith(k) for k in KOOLIE_PRAEFIXE)
+
+
+def ist_deklariert(name: str, praefixe) -> bool:
+    return any(zulaessig(p) and name.startswith(p) for p in praefixe)
+
+
+def fremde_skills(root: str, skills_dir: str) -> list:
+    """Skills der Laufzeitablage ohne Koolie-Praefix, sortiert."""
+    ablage = os.path.join(root, *skills_dir.split("/"))
+    if not os.path.isdir(ablage):
+        return []
+    return sorted(n for n in os.listdir(ablage)
+                  if os.path.isdir(os.path.join(ablage, n)) and not KOOLIE_PRAEFIX_RE.match(n))
+
+
+def markierte_bloecke(text: str) -> list:
+    """(Name, Zeichen) je markiertem Block eines Generators in einer Anweisungsdatei."""
+    return [(m.group(1), len(m.group(0))) for m in MARKE_RE.finditer(text)]
+
+
+def erkennen(root: str, skills_dir: str) -> list:
+    """Je erkanntem Rahmenwerk ein Befund: name, spuren, skills, praefix."""
+    fremd = fremde_skills(root, skills_dir)
+    befunde = []
+    for r in BEKANNT:
+        spuren = [s for s in r["spuren"] if os.path.exists(os.path.join(root, *s.split("/")))]
+        skills = [s for s in fremd if s.startswith(r["praefix"])]
+        if spuren or skills:
+            befunde.append({"name": r["name"], "spuren": spuren, "skills": skills,
+                            "praefix": r["praefix"]})
+    bekannt = {s for b in befunde for s in b["skills"]}
+    rest = [s for s in fremd if s not in bekannt]
+    if rest:
+        befunde.append({"name": "unbekannt", "spuren": [], "skills": rest, "praefix": ""})
+    return befunde