hmgr 0.0.4 → 0.0.6

package/dist/adapter/mcp-katalog.js

@@ -0,0 +1,124 @@
+// Liest den persönlichen MCP-Katalog ~/.hmgr/mcp.yaml (E61). hmgr schreibt ihn nie.
+import { readFile } from 'node:fs/promises';
+import { parseDocument } from 'yaml';
+import { McpKatalogFehler } from "../kern/modell.js";
+const STDIO_FELDER = new Set(['command', 'args', 'env']);
+const URL_FELDER = new Set(['url', 'headers']);
+function fehlertext(fehler) {
+    return fehler instanceof Error ? fehler.message : String(fehler);
+}
+function istObjekt(wert) {
+    return typeof wert === 'object' && wert !== null && !Array.isArray(wert);
+}
+/** Ein optionales Textfeld: fehlt es oder ist es leer, bleibt es weg, kein Fehler. */
+function feldText(pfad, name, o, feld) {
+    if (!(feld in o))
+        return undefined;
+    const wert = o[feld];
+    if (typeof wert !== 'string')
+        throw new McpKatalogFehler(pfad, `Eintrag „${name}": Feld „${feld}" muss Text sein`);
+    const getrimmt = wert.trim();
+    return getrimmt.length === 0 ? undefined : wert;
+}
+/** Eine Zeichenkette-zu-Zeichenkette-Map wie `env` oder `headers`, oder undefined ohne das Feld. */
+function mapLesen(pfad, name, wert, feld) {
+    if (wert === undefined)
+        return undefined;
+    if (!istObjekt(wert))
+        throw new McpKatalogFehler(pfad, `Eintrag „${name}": konfig.${feld} muss ein Objekt sein`);
+    const ergebnis = {};
+    for (const [k, v] of Object.entries(wert)) {
+        if (typeof v !== 'string')
+            throw new McpKatalogFehler(pfad, `Eintrag „${name}": konfig.${feld}.${k} muss Text sein`);
+        ergebnis[k] = v;
+    }
+    return ergebnis;
+}
+/** Eine Liste von Zeichenketten wie `args`, oder undefined ohne das Feld. */
+function argsLesen(pfad, name, wert) {
+    if (wert === undefined)
+        return undefined;
+    if (!Array.isArray(wert))
+        throw new McpKatalogFehler(pfad, `Eintrag „${name}": konfig.args muss eine Liste sein`);
+    return wert.map((eintrag, i) => {
+        if (typeof eintrag !== 'string')
+            throw new McpKatalogFehler(pfad, `Eintrag „${name}": konfig.args[${i}] muss Text sein`);
+        return eintrag;
+    });
+}
+function konfigLesen(pfad, name, k) {
+    const hatCommand = 'command' in k;
+    const hatUrl = 'url' in k;
+    if (hatCommand && hatUrl)
+        throw new McpKatalogFehler(pfad, `Eintrag „${name}": konfig darf nicht zugleich „command" und „url" haben`);
+    if (hatCommand) {
+        for (const feld of Object.keys(k))
+            if (!STDIO_FELDER.has(feld))
+                throw new McpKatalogFehler(pfad, `Eintrag „${name}": unbekanntes Feld „${feld}" in konfig`);
+        const command = k['command'];
+        if (typeof command !== 'string' || command.trim().length === 0)
+            throw new McpKatalogFehler(pfad, `Eintrag „${name}": konfig.command muss nicht leerer Text sein`);
+        const args = argsLesen(pfad, name, k['args']);
+        const env = mapLesen(pfad, name, k['env'], 'env');
+        return { command, ...(args === undefined ? {} : { args }), ...(env === undefined ? {} : { env }) };
+    }
+    if (hatUrl) {
+        for (const feld of Object.keys(k))
+            if (!URL_FELDER.has(feld))
+                throw new McpKatalogFehler(pfad, `Eintrag „${name}": unbekanntes Feld „${feld}" in konfig`);
+        const url = k['url'];
+        if (typeof url !== 'string' || url.trim().length === 0)
+            throw new McpKatalogFehler(pfad, `Eintrag „${name}": konfig.url muss nicht leerer Text sein`);
+        const headers = mapLesen(pfad, name, k['headers'], 'headers');
+        return { url, ...(headers === undefined ? {} : { headers }) };
+    }
+    throw new McpKatalogFehler(pfad, `Eintrag „${name}": konfig braucht entweder „command" oder „url"`);
+}
+function eintragLesen(pfad, name, roh) {
+    if (!istObjekt(roh))
+        throw new McpKatalogFehler(pfad, `Eintrag „${name}" ist kein Objekt`);
+    const beschreibung = roh['beschreibung'];
+    if (typeof beschreibung !== 'string' || beschreibung.trim().length === 0)
+        throw new McpKatalogFehler(pfad, `Eintrag „${name}" braucht eine Beschreibung (Feld „beschreibung")`);
+    const homepage = feldText(pfad, name, roh, 'homepage');
+    const notizen = feldText(pfad, name, roh, 'notizen');
+    const konfigRoh = roh['konfig'];
+    if (!istObjekt(konfigRoh))
+        throw new McpKatalogFehler(pfad, `Eintrag „${name}" braucht einen Konfigblock (Feld „konfig")`);
+    const konfig = konfigLesen(pfad, name, konfigRoh);
+    return {
+        name,
+        beschreibung,
+        ...(homepage === undefined ? {} : { homepage }),
+        ...(notizen === undefined ? {} : { notizen }),
+        konfig,
+    };
+}
+export class DateiMcpKatalog {
+    pfad;
+    constructor(pfad) {
+        this.pfad = pfad;
+    }
+    /** Fehlende Datei: leerer Katalog, kein Fehler. Kaputtes YAML oder falsches Format: Fehler mit Pfad. */
+    async lesen() {
+        let text;
+        try {
+            text = await readFile(this.pfad, 'utf8');
+        }
+        catch {
+            return [];
+        }
+        let daten;
+        try {
+            daten = parseDocument(text, { strict: true }).toJS();
+        }
+        catch (fehler) {
+            throw new McpKatalogFehler(this.pfad, `kaputtes YAML: ${fehlertext(fehler)}`);
+        }
+        if (daten === null || daten === undefined)
+            return [];
+        if (!istObjekt(daten))
+            throw new McpKatalogFehler(this.pfad, 'die Datei muss ein Objekt mit einem Eintrag je MCP-Name sein');
+        return Object.entries(daten).map(([name, roh]) => eintragLesen(this.pfad, name, roh));
+    }
+}

package/dist/adapter/quelle-text.js

@@ -1,8 +1,17 @@
 import path from 'node:path';
+import { istWindowsLaufwerkspfad } from "../kern/quelle-ort.js";
 export { quelleAlsText } from "../kern/modell.js";
-/** URL heißt Git-Quelle mit Checkout, ein nackter Pfad heißt lokale Arbeitskopie ohne Clone (B11). */
+/**
+ * URL heißt Git-Quelle mit Checkout, ein nackter Pfad heißt lokale Arbeitskopie ohne Clone (B11).
+ *
+ * Ein Windows-Laufwerkspfad ist ein nackter Pfad (E65/B12): `C:\work\quelle` traf sonst die
+ * scp-Regel `host:pfad` — Host „C" — und `hmgr source add C:\work\quelle` legte die Arbeitskopie
+ * als Git-Quelle mit Remote an statt als lokale. Sichtbar wurde das am Anzeigenamen „\work\quelle".
+ */
 export function quelleAusText(text) {
     const roh = text.trim();
+    if (istWindowsLaufwerkspfad(roh))
+        return { art: 'lokal', pfad: path.resolve(roh) };
     if (roh.includes('://') || /^(?:[^@/\s]+@)?[^@/:\s]+:[^/\s]/.test(roh))
         return { art: 'git', url: roh };
     return { art: 'lokal', pfad: path.resolve(roh) };

package/dist/adapter/skill-md.js

@@ -1,9 +1,10 @@
-// Name eines Skills: `name` aus dem Frontmatter der SKILL.md, sonst der Verzeichnisname (E32).
+// Name, Beschreibung und Besonderheiten eines Skills aus dem Frontmatter der SKILL.md (E32, E39, E55).
 import { parse } from 'yaml';
+import { ohneBom } from "./datei-text.js";
 export const SKILL_DATEI = 'SKILL.md';
 /** Der Block zwischen der ersten Zeile `---` und der nächsten Zeile `---`. Fehlt er, undefined. */
 function frontmatter(inhalt) {
-    const zeilen = inhalt.replace(/^\uFEFF/, '').split('\n');
+    const zeilen = ohneBom(inhalt).split('\n');
     if (zeilen[0]?.trimEnd() !== '---')
         return undefined;
     for (let i = 1; i < zeilen.length; i += 1)
@@ -12,38 +13,114 @@ function frontmatter(inhalt) {
     return undefined;
 }
 /**
- * Der Verzeichnisname ist nur Konvention, das Frontmatter ist die Aussage des Autors (E18, E32).
- * Ohne Frontmatter, ohne YAML-Objekt, bei kaputtem YAML oder ohne nicht leeren `name` gilt der
- * Verzeichnisname. Ein Name mit Pfadtrenner gilt nicht, aus ihm würde im Ziel kein Eintrag,
- * sondern ein Pfad.
+ * Das Frontmatter als Objekt, einmal geparst für alle Felder. Fehlt der Block, ist das YAML
+ * kaputt oder liest es sich nicht als Objekt, gibt es kein Ergebnis (E32).
  */
-export function skillName(verzeichnisname, skillMdInhalt) {
+function frontmatterDaten(skillMdInhalt) {
     if (skillMdInhalt === undefined)
-        return verzeichnisname;
+        return undefined;
     const block = frontmatter(skillMdInhalt);
     if (block === undefined)
-        return verzeichnisname;
+        return undefined;
     let daten;
     try {
         daten = parse(block);
     }
     catch {
-        return verzeichnisname;
+        return undefined;
     }
     if (typeof daten !== 'object' || daten === null || Array.isArray(daten))
-        return verzeichnisname;
-    const roh = daten['name'];
+        return undefined;
+    return daten;
+}
+/** Ein Textfeld, getrimmt, leer heißt „nicht vorhanden" (E39). */
+function textFeld(daten, feld) {
+    const roh = daten?.[feld];
     if (typeof roh !== 'string')
-        return verzeichnisname;
-    const name = roh.trim();
-    if (name.length === 0 || name === '.' || name === '..')
+        return undefined;
+    const wert = roh.trim();
+    return wert.length === 0 ? undefined : wert;
+}
+/** Ein boolesches Feld mit dem genannten erwarteten Wert, sonst „nicht vorhanden" (E55). */
+function boolFeld(daten, feld, erwartet) {
+    return daten?.[feld] === erwartet ? true : undefined;
+}
+/**
+ * Ein Feld, das vorhanden und nicht leer sein muss, unabhängig von seiner Art (E55: hooks,
+ * allowed-tools). Leere Liste, leeres Objekt, leerer Text und `false` heißen „nicht vorhanden":
+ * beides sind Arten zu sagen, dass es nichts gibt, und die Marke behauptete sonst etwas
+ * Sicherheitsrelevantes, das nicht dasteht.
+ */
+function vorhandenFeld(daten, feld) {
+    const roh = daten?.[feld];
+    if (roh === undefined || roh === null || roh === false)
+        return undefined;
+    if (typeof roh === 'string')
+        return roh.trim().length > 0 ? true : undefined;
+    if (Array.isArray(roh))
+        return roh.length > 0 ? true : undefined;
+    if (typeof roh === 'object')
+        return Object.keys(roh).length > 0 ? true : undefined;
+    return true;
+}
+/**
+ * Der Verzeichnisname ist nur Konvention, das Frontmatter ist die Aussage des Autors (E18, E32).
+ * Ohne Frontmatter, ohne YAML-Objekt, bei kaputtem YAML oder ohne nicht leeren `name` gilt der
+ * Verzeichnisname. Ein Name mit Pfadtrenner gilt nicht, aus ihm würde im Ziel kein Eintrag,
+ * sondern ein Pfad.
+ */
+function nameAus(daten, verzeichnisname) {
+    const name = textFeld(daten, 'name');
+    if (name === undefined || name === '.' || name === '..')
         return verzeichnisname;
     if (name.includes('/') || name.includes('\\'))
         return verzeichnisname;
     return name;
 }
-/** Skill aus seinem Pfad in der Quelle, Name nach `skillName`. */
-export function skillAusPfad(pfad, skillMdInhalt) {
-    const verzeichnisname = pfad.split('/').filter((t) => t.length > 0).at(-1) ?? pfad;
-    return { name: skillName(verzeichnisname, skillMdInhalt), pfad };
+/** Name eines Skills aus dem Frontmatter, sonst der Verzeichnisname (E32). */
+export function skillName(verzeichnisname, skillMdInhalt) {
+    return nameAus(frontmatterDaten(skillMdInhalt), verzeichnisname);
+}
+/**
+ * Beschreibung eines Skills aus dem Feld `description` im Frontmatter (E39), analog zur
+ * Namensregel E32: fehlendes Frontmatter, kein YAML-Objekt, kaputtes YAML oder kein nicht leerer
+ * Text ⇒ keine Beschreibung, nichts bricht ab.
+ */
+export function skillBeschreibung(skillMdInhalt) {
+    return textFeld(frontmatterDaten(skillMdInhalt), 'description');
+}
+/**
+ * Skill aus seinem Pfad in der Quelle: Name nach `skillName`, Beschreibung nach
+ * `skillBeschreibung`, Besonderheiten aus dem Frontmatter (E55), jedes Feld nur gesetzt, wenn
+ * etwas da ist. Das Frontmatter wird dafür einmal geparst, nicht je Feld: der Katalog einer Quelle
+ * geht über alle ihre Skills. `ersatzname` greift nur, wenn der Pfad kein Segment hergibt.
+ */
+export function skillAusPfad(pfad, skillMdInhalt, ersatzname) {
+    const verzeichnisname = pfad.split('/').filter((t) => t.length > 0).at(-1) ?? ersatzname ?? pfad;
+    const daten = frontmatterDaten(skillMdInhalt);
+    const skill = { name: nameAus(daten, verzeichnisname), pfad };
+    const beschreibung = textFeld(daten, 'description');
+    if (beschreibung !== undefined)
+        skill.beschreibung = beschreibung;
+    // `disable-model-invocation: true`: lädt erst bei `/name`. `user-invocable: false`: kein `/name`.
+    if (boolFeld(daten, 'disable-model-invocation', true))
+        skill.nurPerBefehl = true;
+    if (boolFeld(daten, 'user-invocable', false))
+        skill.nichtPerBefehl = true;
+    if (vorhandenFeld(daten, 'hooks'))
+        skill.registriertHooks = true;
+    if (vorhandenFeld(daten, 'allowed-tools'))
+        skill.werkzeugeErlaubt = true;
+    const kompatibilitaet = textFeld(daten, 'compatibility');
+    if (kompatibilitaet !== undefined)
+        skill.kompatibilitaet = kompatibilitaet;
+    const modell = textFeld(daten, 'model');
+    if (modell !== undefined)
+        skill.modell = modell;
+    if (textFeld(daten, 'context') === 'fork')
+        skill.eigenerKontext = true;
+    const argumentHinweis = textFeld(daten, 'argument-hint');
+    if (argumentHinweis !== undefined)
+        skill.argumentHinweis = argumentHinweis;
+    return skill;
 }

package/dist/adapter/terminal.js

@@ -14,7 +14,7 @@ export class TerminalRueckfrage {
             return false;
         const leser = createInterface({ input: process.stdin, output: process.stdout });
         try {
-            const antwort = await leser.question(`${frage} `);
+            const antwort = await leser.question(`${frage} [j/N] `);
             return JA.has(antwort.trim().toLowerCase());
         }
         finally {

package/dist/adapter/umgebung.js

@@ -0,0 +1,43 @@
+// Prozess-Umgebung und .env-Dateien, für die F39-Prüfung beim MCP-Einhängen (E61).
+import { readFile } from 'node:fs/promises';
+export class ProzessUmgebung {
+    env;
+    constructor(env = process.env) {
+        this.env = env;
+    }
+    variablen() {
+        const ergebnis = {};
+        for (const [name, wert] of Object.entries(this.env))
+            if (wert !== undefined)
+                ergebnis[name] = wert;
+        return ergebnis;
+    }
+    /**
+     * Liest NAME=wert-Zeilen. Leere Zeilen und solche, die mit „#" beginnen, zählen nicht. Werte in
+     * einfachen oder doppelten Anführungszeichen werden davon befreit, sonst unverändert übernommen.
+     */
+    async envDatei(pfad) {
+        let text;
+        try {
+            text = await readFile(pfad, 'utf8');
+        }
+        catch {
+            return {};
+        }
+        const ergebnis = {};
+        for (const zeile of text.split('\n')) {
+            const getrimmt = zeile.trim();
+            if (getrimmt.length === 0 || getrimmt.startsWith('#'))
+                continue;
+            const trenner = getrimmt.indexOf('=');
+            if (trenner <= 0)
+                continue;
+            const name = getrimmt.slice(0, trenner).trim();
+            let wert = getrimmt.slice(trenner + 1).trim();
+            if (wert.length >= 2 && ((wert.startsWith('"') && wert.endsWith('"')) || (wert.startsWith("'") && wert.endsWith("'"))))
+                wert = wert.slice(1, -1);
+            ergebnis[name] = wert;
+        }
+        return ergebnis;
+    }
+}

package/dist/adapter/vergleich.js

@@ -0,0 +1,20 @@
+// Gemeinsames Modul der Adapter: Vergleich zweier aus YAML oder JSON gelesener Werte.
+/**
+ * Tiefer Vergleich, ohne Rücksicht auf die Schlüsselreihenfolge. Gebraucht, wo ein Adapter einen
+ * schon vorhandenen MCP-Eintrag gegen den Katalogblock hält (E61): gleicher Block heißt „schon
+ * eingehängt", ein abweichender wird nie stillschweigend überschrieben.
+ */
+export function tiefGleich(a, b) {
+    if (a === b)
+        return true;
+    if (Array.isArray(a) || Array.isArray(b))
+        return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((v, i) => tiefGleich(v, b[i]));
+    if (typeof a === 'object' && a !== null && typeof b === 'object' && b !== null) {
+        const ak = Object.keys(a).sort();
+        const bk = Object.keys(b).sort();
+        if (ak.length !== bk.length || ak.some((k, i) => k !== bk[i]))
+            return false;
+        return ak.every((k) => tiefGleich(a[k], b[k]));
+    }
+    return false;
+}

package/dist/adapter/zustand-json.js

@@ -2,6 +2,7 @@
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { leererZustand } from "../ports/zustand.js";
+import { ohneBom } from "./datei-text.js";
 export class ZustandJson {
     pfad;
     constructor(pfad) {
@@ -11,11 +12,15 @@ export class ZustandJson {
         const roh = await readFile(this.pfad, 'utf8').catch(() => undefined);
         if (roh === undefined)
             return leererZustand();
-        const daten = JSON.parse(roh);
+        const daten = JSON.parse(ohneBom(roh));
         return {
             quellen: (daten.quellen ?? []),
             arbeitsverzeichnisse: (daten.arbeitsverzeichnisse ?? []),
             bindungen: (daten.bindungen ?? []),
+            // Fehlt das Feld (state.json vor E38), gilt der bisherige Ist-Zustand: nur claude-code aktiv.
+            aktiveHarnesses: (daten.aktiveHarnesses ?? ['claude-code']),
+            // Fehlt das Feld (state.json vor E43), gilt: nichts ignoriert.
+            ignorierteEintraege: (daten.ignorierteEintraege ?? []),
         };
     }
     async schreiben(zustand) {