hmgr 0.0.1

package/dist/adapter/git.js

@@ -0,0 +1,339 @@
+// Git über die CLI, keine Bibliothek. Checkout-Schema und Worktrees nach E22, Discovery nach E11.
+import { execFile, spawn } from 'node:child_process';
+import { readFile, readdir, mkdir, realpath, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { marketplaceLesen } from "./marketplace-json.js";
+import { SKILL_DATEI, skillAusPfad } from "./skill-md.js";
+import { BASIS_NAME, basisPfad, quelleZerlegen, refDekodieren, worktreePfad } from "./checkout-pfad.js";
+const ausfuehren = promisify(execFile);
+/** Bekannte Orte für Skills, in dieser Reihenfolge (E11). */
+export const BEKANNTE_ORTE = ['skills', '.claude/skills', '.agents/skills'];
+/** Eine lokale Arbeitskopie hat für hmgr keinen Ref, es zählt der Stand auf der Platte (B11). */
+export const LOKAL_REF = 'lokal';
+/** Pfad der Marketplace-Datei in einer Quelle (E24). */
+export const MARKETPLACE_DATEI = '.claude-plugin/marketplace.json';
+/**
+ * Muster, die in jedem Worktree gelten (E11): alle Dateien direkt an der Wurzel und das
+ * Verzeichnis .claude-plugin. Das zweite Muster nimmt die Wurzelverzeichnisse wieder heraus,
+ * die gewählten Skills kommen danach einzeln zurück.
+ */
+export const WURZEL_MUSTER = ['/*', '!/*/', `/${MARKETPLACE_DATEI.split('/')[0]}/`];
+async function existiert(pfad) {
+    try {
+        await stat(pfad);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Aus Dateipfaden die Skill-Verzeichnisse bilden: ein Verzeichnis mit SKILL.md ist ein Skill.
+ * Bekannte Orte zuerst (E11). Den Namen bekommt der Skill erst aus seiner SKILL.md (E32).
+ */
+export function skillPfadeAusDateien(dateien) {
+    const verzeichnisse = new Set();
+    for (const datei of dateien) {
+        const teile = datei.split('/');
+        if (teile.at(-1) !== SKILL_DATEI || teile.length < 2)
+            continue;
+        verzeichnisse.add(teile.slice(0, -1).join('/'));
+    }
+    const sortiert = [...verzeichnisse].sort();
+    const genommen = new Set();
+    const ergebnis = [];
+    for (const ort of BEKANNTE_ORTE)
+        for (const verzeichnis of sortiert)
+            if (verzeichnis.startsWith(`${ort}/`) && verzeichnis.slice(ort.length + 1).indexOf('/') === -1) {
+                genommen.add(verzeichnis);
+                ergebnis.push(verzeichnis);
+            }
+    for (const verzeichnis of sortiert)
+        if (!genommen.has(verzeichnis))
+            ergebnis.push(verzeichnis);
+    return ergebnis;
+}
+/**
+ * Ausgabe von `git cat-file --batch` zerlegen: je Eingabezeile ein Kopf `<sha> <typ> <größe>`,
+ * danach `<größe>` Bytes Inhalt und ein Zeilenumbruch. Fehlt das Objekt, steht statt des Kopfes
+ * `<eingabe> missing`, dann folgt kein Inhalt. Die Größe zählt Bytes, deshalb wird auf dem Buffer
+ * gerechnet und erst der einzelne Inhalt als UTF-8 gelesen.
+ */
+export function batchInhalte(ausgabe, schluessel) {
+    const ergebnis = new Map();
+    let pos = 0;
+    for (const eintrag of schluessel) {
+        const zeilenende = ausgabe.indexOf(10, pos);
+        if (zeilenende === -1)
+            break;
+        const kopf = ausgabe.toString('utf8', pos, zeilenende);
+        pos = zeilenende + 1;
+        const trenner = kopf.lastIndexOf(' ');
+        const groesse = trenner === -1 ? Number.NaN : Number(kopf.slice(trenner + 1));
+        if (!Number.isInteger(groesse) || groesse < 0)
+            continue;
+        ergebnis.set(eintrag, ausgabe.toString('utf8', pos, pos + groesse));
+        pos += groesse + 1;
+    }
+    return ergebnis;
+}
+/** Namen der Unterverzeichnisse, sortiert. Fehlt das Verzeichnis, ist die Liste leer. */
+async function verzeichnisse(pfad) {
+    const eintraege = await readdir(pfad, { withFileTypes: true }).catch(() => []);
+    return eintraege
+        .filter((e) => e.isDirectory())
+        .map((e) => e.name)
+        .sort();
+}
+/** SKILL.md-Inhalte einer lokalen Quelle. Was nicht lesbar ist, fehlt in der Karte. */
+async function inhalteAufPlatte(wurzel, pfade) {
+    const ergebnis = new Map();
+    for (const pfad of pfade) {
+        const roh = await readFile(path.join(wurzel, pfad, SKILL_DATEI), 'utf8').catch(() => undefined);
+        if (roh !== undefined)
+            ergebnis.set(pfad, roh);
+    }
+    return ergebnis;
+}
+async function dateienAufPlatte(wurzel, unter = '') {
+    const eintraege = await readdir(path.join(wurzel, unter), { withFileTypes: true }).catch(() => []);
+    const dateien = [];
+    for (const eintrag of eintraege) {
+        if (eintrag.name === '.git' || eintrag.name === 'node_modules' || eintrag.name === 'vendor')
+            continue;
+        const rel = unter ? `${unter}/${eintrag.name}` : eintrag.name;
+        if (eintrag.isDirectory())
+            dateien.push(...(await dateienAufPlatte(wurzel, rel)));
+        else
+            dateien.push(rel);
+    }
+    return dateien;
+}
+export class GitQuellen {
+    wurzel;
+    constructor(wurzel) {
+        this.wurzel = wurzel;
+    }
+    async git(args, cwd) {
+        const { stdout } = await ausfuehren('git', args, { cwd, maxBuffer: 32 * 1024 * 1024 });
+        return stdout;
+    }
+    /** Wie `git`, aber mit Text auf stdin und Bytes als Ergebnis: `execFile` kennt keine Eingabe. */
+    async gitMitEingabe(args, cwd, eingabe) {
+        return await new Promise((erfuellen, ablehnen) => {
+            const kind = spawn('git', args, { cwd });
+            const stuecke = [];
+            const fehler = [];
+            kind.stdout.on('data', (teil) => stuecke.push(teil));
+            kind.stderr.on('data', (teil) => fehler.push(teil));
+            kind.on('error', ablehnen);
+            kind.on('close', (code) => {
+                if (code === 0)
+                    erfuellen(Buffer.concat(stuecke));
+                else
+                    ablehnen(new Error(`git ${args.join(' ')}: ${Buffer.concat(fehler).toString('utf8')}`));
+            });
+            kind.stdin.on('error', ablehnen);
+            kind.stdin.end(eingabe);
+        });
+    }
+    /** Basis-Clone je Repo: bare, ohne Blobs (E11, E22). */
+    async basis(quelle) {
+        if (quelle.art !== 'git')
+            throw new Error('Lokale Quellen haben keinen Basis-Clone');
+        const pfad = basisPfad(this.wurzel, quelleZerlegen(quelle));
+        if (await existiert(pfad))
+            return pfad;
+        await mkdir(path.dirname(pfad), { recursive: true });
+        await this.git(['clone', '--bare', '--filter=blob:none', quelle.url, pfad], path.dirname(pfad));
+        // Ein bare Clone bekommt keine Fetch-Refspec, ohne sie holt „fetch" nichts.
+        await this.git(['config', 'remote.origin.fetch', '+refs/heads/*:refs/heads/*'], pfad);
+        return pfad;
+    }
+    /**
+     * Inhalte der SKILL.md aller genannten Skills in einem Aufruf. `git cat-file --batch` holt beim
+     * Partial Clone (`--filter=blob:none`) die fehlenden Blobs gebündelt, ein `git show` je Skill
+     * würde je Skill einen Fetch auslösen. Ein Skill ohne lesbare SKILL.md fehlt in der Karte.
+     */
+    async skillMdInhalte(basis, ref, pfade) {
+        if (pfade.length === 0)
+            return new Map();
+        const eingabe = `${pfade.map((p) => `${ref}:${p}/${SKILL_DATEI}`).join('\n')}\n`;
+        const ausgabe = await this.gitMitEingabe(['cat-file', '--batch'], basis, eingabe).catch(() => undefined);
+        if (ausgabe === undefined)
+            return new Map();
+        return batchInhalte(ausgabe, pfade);
+    }
+    /** Skills der Quelle, Namen aus dem Frontmatter der SKILL.md (E32). */
+    async skills(quelle, ref) {
+        if (quelle.art === 'lokal') {
+            const pfade = skillPfadeAusDateien(await dateienAufPlatte(quelle.pfad));
+            const inhalte = await inhalteAufPlatte(quelle.pfad, pfade);
+            return pfade.map((pfad) => skillAusPfad(pfad, inhalte.get(pfad)));
+        }
+        const basis = await this.basis(quelle);
+        const ausgabe = await this.git(['ls-tree', '-r', '--name-only', ref], basis);
+        const pfade = skillPfadeAusDateien(ausgabe.split('\n').filter((z) => z.length > 0));
+        const inhalte = await this.skillMdInhalte(basis, ref, pfade);
+        return pfade.map((pfad) => skillAusPfad(pfad, inhalte.get(pfad)));
+    }
+    /**
+     * Marketplace einer Quelle (E24). Der Inhalt kommt aus dem Git-Baum, nicht aus einem Checkout:
+     * bei einem Clone mit `blob:none` holt `git show` den Blob nach.
+     */
+    async marketplace(quelle, ref) {
+        let roh;
+        let dateien;
+        if (quelle.art === 'lokal') {
+            roh = await readFile(path.join(quelle.pfad, MARKETPLACE_DATEI), 'utf8').catch(() => undefined);
+            dateien = await dateienAufPlatte(quelle.pfad);
+        }
+        else {
+            const basis = await this.basis(quelle);
+            roh = await this.git(['show', `${ref}:${MARKETPLACE_DATEI}`], basis).catch(() => undefined);
+            dateien = (await this.git(['ls-tree', '-r', '--name-only', ref], basis)).split('\n').filter((z) => z.length > 0);
+        }
+        if (roh === undefined)
+            return null;
+        const gelesen = marketplaceLesen(roh, dateien);
+        const pfade = [...new Set(gelesen.plugins.flatMap((p) => p.skills))];
+        const inhalte = quelle.art === 'lokal'
+            ? await inhalteAufPlatte(quelle.pfad, pfade)
+            : await this.skillMdInhalte(await this.basis(quelle), ref, pfade);
+        return {
+            name: gelesen.name,
+            plugins: gelesen.plugins.map((p) => ({
+                name: p.name,
+                dependencies: p.dependencies,
+                skills: p.skills.map((pfad) => skillAusPfad(pfad, inhalte.get(pfad))),
+            })),
+        };
+    }
+    async refs(quelle) {
+        if (quelle.art === 'lokal')
+            return [LOKAL_REF];
+        const basis = await this.basis(quelle);
+        const ausgabe = await this.git(['for-each-ref', '--format=%(refname:short)', 'refs/heads', 'refs/tags'], basis);
+        return ausgabe.split('\n').filter((z) => z.length > 0);
+    }
+    /** Nur die Tags: eine Versionseinschränkung wählt nie einen Branch (E33). */
+    async tags(quelle) {
+        if (quelle.art === 'lokal')
+            return [];
+        const basis = await this.basis(quelle);
+        const ausgabe = await this.git(['for-each-ref', '--format=%(refname:short)', 'refs/tags'], basis);
+        return ausgabe.split('\n').filter((z) => z.length > 0);
+    }
+    async standardRef(quelle) {
+        if (quelle.art === 'lokal')
+            return LOKAL_REF;
+        const basis = await this.basis(quelle);
+        try {
+            return (await this.git(['symbolic-ref', '--short', 'HEAD'], basis)).trim();
+        }
+        catch {
+            return (await this.git(['rev-parse', 'HEAD'], basis)).trim();
+        }
+    }
+    async checkout(quelle, ref, skills) {
+        // Lokale Quellen werden nicht geklont, der Pfad selbst ist der Checkout (B11).
+        if (quelle.art === 'lokal')
+            return { quelle, ref, pfad: quelle.pfad };
+        const basis = await this.basis(quelle);
+        const pfad = worktreePfad(this.wurzel, quelleZerlegen(quelle), ref);
+        const neu = !(await existiert(pfad));
+        if (neu) {
+            await mkdir(path.dirname(pfad), { recursive: true });
+            await this.git(['worktree', 'add', '--detach', '--no-checkout', pfad, ref], basis);
+            await this.git(['sparse-checkout', 'init', '--no-cone'], pfad);
+        }
+        const vorhanden = neu
+            ? []
+            : (await this.git(['sparse-checkout', 'list'], pfad)).split('\n').filter((z) => z.length > 0);
+        // Wurzelmuster stehen immer vorn, danach die Skills. Das letzte passende Muster gewinnt.
+        const muster = new Set(WURZEL_MUSTER);
+        for (const eintrag of vorhanden)
+            if (!WURZEL_MUSTER.includes(eintrag))
+                muster.add(eintrag);
+        for (const skill of skills)
+            muster.add(`/${skill.pfad}/`);
+        await this.git(['sparse-checkout', 'set', '--no-cone', '--', ...muster], pfad);
+        if (neu)
+            await this.git(['checkout', '--detach', ref], pfad);
+        return { quelle, ref, pfad };
+    }
+    /**
+     * Alle Checkouts unter der Wurzel, aus dem Dateisystem gelesen (E19). Die Quelle kommt aus der
+     * Remote-URL des Basis-Clones, sie wird nicht aus dem Pfad erraten (E22).
+     */
+    async checkouts() {
+        const ergebnis = [];
+        for (const host of await verzeichnisse(this.wurzel))
+            for (const besitzer of await verzeichnisse(path.join(this.wurzel, host)))
+                for (const repo of await verzeichnisse(path.join(this.wurzel, host, besitzer))) {
+                    const repoPfad = path.join(this.wurzel, host, besitzer, repo);
+                    const basis = path.join(repoPfad, BASIS_NAME);
+                    if (!(await existiert(basis)))
+                        continue;
+                    const url = (await this.git(['config', '--get', 'remote.origin.url'], basis).catch(() => '')).trim();
+                    if (url.length === 0)
+                        continue;
+                    for (const refTeil of await verzeichnisse(repoPfad)) {
+                        if (refTeil === BASIS_NAME)
+                            continue;
+                        ergebnis.push({
+                            quelle: { art: 'git', url },
+                            ref: refDekodieren(refTeil),
+                            pfad: path.join(repoPfad, refTeil),
+                        });
+                    }
+                }
+        return ergebnis;
+    }
+    async aktualisieren(checkout) {
+        if (checkout.quelle.art === 'lokal')
+            return { ergebnis: 'unveraendert' };
+        if (await this.lokaleAenderungen(checkout))
+            return { ergebnis: 'uebersprungen', grund: 'lokale-aenderung' }; // E15
+        const basis = await this.basis(checkout.quelle);
+        const von = (await this.git(['rev-parse', 'HEAD'], checkout.pfad)).trim();
+        await this.git(['fetch', '--prune', '--tags', 'origin'], basis);
+        const nach = (await this.git(['rev-parse', checkout.ref], basis)).trim();
+        if (von === nach)
+            return { ergebnis: 'unveraendert' };
+        await this.git(['checkout', '--detach', checkout.ref], checkout.pfad);
+        return { ergebnis: 'aktualisiert', von, nach };
+    }
+    /**
+     * Arbeitskopie um einen Pfad herum (B12). Die Wurzel kommt aus `rev-parse --show-toplevel`, vom
+     * Verzeichnis des Pfads aus gefragt. Beide Pfade werden über realpath aufgelöst, sonst passen
+     * ein Linkziel unter /var und eine Wurzel unter /private/var nicht zusammen.
+     */
+    async arbeitskopie(pfad) {
+        const echt = await realpath(pfad).catch(() => undefined);
+        if (echt === undefined)
+            return null;
+        const info = await stat(echt).catch(() => undefined);
+        const von = info?.isDirectory() === true ? echt : path.dirname(echt);
+        const roh = await this.git(['rev-parse', '--show-toplevel'], von).catch(() => undefined);
+        if (roh === undefined || roh.trim().length === 0)
+            return null;
+        const wurzel = await realpath(roh.trim()).catch(() => roh.trim());
+        const url = (await this.git(['config', '--get', 'remote.origin.url'], wurzel).catch(() => '')).trim();
+        // `--abbrev-ref HEAD` liefert bei detached HEAD den Namen „HEAD", das ist kein Branch.
+        const zweig = (await this.git(['rev-parse', '--abbrev-ref', 'HEAD'], wurzel).catch(() => '')).trim();
+        return {
+            wurzel,
+            url: url.length === 0 ? null : url,
+            ref: zweig.length === 0 || zweig === 'HEAD' ? null : zweig,
+            relativerPfad: path.relative(wurzel, echt).split(path.sep).join('/'),
+        };
+    }
+    async lokaleAenderungen(checkout) {
+        if (checkout.quelle.art === 'lokal')
+            return false;
+        const ausgabe = await this.git(['status', '--porcelain'], checkout.pfad);
+        return ausgabe.trim().length > 0;
+    }
+}

package/dist/adapter/gitignore.js

@@ -0,0 +1,16 @@
+// Verzeichnisse eines Harness dürfen nicht ins Repo eines Arbeitsverzeichnisses (B7).
+import { readFile, stat, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+export async function istGitRepo(verzeichnis) {
+    return (await stat(path.join(verzeichnis, '.git')).catch(() => undefined)) !== undefined;
+}
+/** Trägt `zeile` (etwa „.claude/") in die .gitignore ein, falls sie fehlt. Idempotent. */
+export async function gitignoreEintragen(verzeichnis, zeile) {
+    const pfad = path.join(verzeichnis, '.gitignore');
+    const ohneSlash = zeile.endsWith('/') ? zeile.slice(0, -1) : zeile;
+    const inhalt = await readFile(pfad, 'utf8').catch(() => '');
+    if (inhalt.split('\n').some((z) => z.trim() === zeile || z.trim() === ohneSlash))
+        return;
+    const getrennt = inhalt.length === 0 || inhalt.endsWith('\n') ? inhalt : `${inhalt}\n`;
+    await writeFile(pfad, `${getrennt}${zeile}\n`);
+}

package/dist/adapter/hermes.js

@@ -0,0 +1,142 @@
+// Hermes Agent: Grundverhalten plus Profile entdecken und Verzeichnis in der config.yaml registrieren.
+// Skills landen nie in <hermes-home>/skills, sondern in einem Ordner aus skills.external_dirs (E13).
+import { readFileSync } from 'node:fs';
+import { mkdir, readFile, readdir, stat, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { Document, isSeq, parseDocument } from 'yaml';
+import { OrtNichtUnterstuetzt } from "../kern/modell.js";
+import { gitignoreEintragen, istGitRepo } from "./gitignore.js";
+const HERMES_VERZEICHNIS = '.hermes';
+const PROFILE_VERZEICHNIS = 'profiles';
+const CONFIG = 'config.yaml';
+const STANDARD_ORDNER = 'external-skills';
+/** Von Hermes selbst verwalteter Ordner, in den hmgr nichts legt (E13). */
+const EIGENER_ORDNER = 'skills';
+const GITIGNORE_ZEILE = '.hermes/';
+function unterhalb(pfad, basis) {
+    const rel = path.relative(basis, pfad);
+    return rel.length > 0 && !rel.startsWith('..') && !path.isAbsolute(rel);
+}
+/** Liest skills.external_dirs aus einer geparsten config.yaml. Fehlt etwas, ist die Liste leer. */
+function externalDirs(daten) {
+    if (typeof daten !== 'object' || daten === null)
+        return [];
+    const skills = daten['skills'];
+    if (typeof skills !== 'object' || skills === null)
+        return [];
+    const dirs = skills['external_dirs'];
+    if (!Array.isArray(dirs))
+        return [];
+    return dirs.filter((d) => typeof d === 'string');
+}
+export class Hermes {
+    name = 'hermes';
+    home;
+    /** `home` ist das HOME des Nutzers, das Hermes-Home liegt darunter als `.hermes`. */
+    constructor(home) {
+        this.home = home;
+    }
+    /** Hermes liegt auf dem Rechner, wenn es sein Home angelegt hat. */
+    async vorhanden() {
+        return (await stat(path.join(this.home, HERMES_VERZEICHNIS)).catch(() => undefined)) !== undefined;
+    }
+    orte() {
+        return ['home', 'profil', 'arbeitsverzeichnis'];
+    }
+    /** Home und Profil sind dasselbe Konzept: ein vollständiges Hermes-Home (E13). */
+    hermesHome(ort) {
+        const basis = path.join(this.home, HERMES_VERZEICHNIS);
+        if (ort.art === 'home')
+            return basis;
+        if (ort.art === 'profil')
+            return path.join(basis, PROFILE_VERZEICHNIS, ort.name);
+        throw new OrtNichtUnterstuetzt(this.name, ort.art);
+    }
+    /** Tilde gegen HOME, relative Pfade gegen das Hermes-Home. Variablen löst hmgr nicht auf. */
+    aufloesen(eintrag, hermesHome) {
+        if (eintrag.includes('$'))
+            return undefined;
+        if (eintrag === '~')
+            return this.home;
+        if (eintrag.startsWith('~/'))
+            return path.join(this.home, eintrag.slice(2));
+        return path.resolve(hermesHome, eintrag);
+    }
+    /** Schreibweise für die config.yaml: `~/…`, solange der Ordner unter HOME liegt. */
+    alsEintrag(verzeichnis) {
+        if (!unterhalb(verzeichnis, this.home))
+            return verzeichnis;
+        return `~/${path.relative(this.home, verzeichnis).split(path.sep).join('/')}`;
+    }
+    gelesen(hermesHome) {
+        const pfad = path.join(hermesHome, CONFIG);
+        let text;
+        try {
+            text = readFileSync(pfad, 'utf8');
+        }
+        catch {
+            return undefined;
+        }
+        return parseDocument(text).toJS();
+    }
+    zielVerzeichnis(ort) {
+        if (ort.art === 'arbeitsverzeichnis')
+            return path.join(ort.pfad, HERMES_VERZEICHNIS, EIGENER_ORDNER);
+        const hermesHome = this.hermesHome(ort);
+        const eigenerOrdner = path.join(hermesHome, EIGENER_ORDNER);
+        for (const eintrag of externalDirs(this.gelesen(hermesHome))) {
+            const pfad = this.aufloesen(eintrag, hermesHome);
+            if (pfad === undefined || !unterhalb(pfad, hermesHome))
+                continue;
+            if (pfad === eigenerOrdner || unterhalb(pfad, eigenerOrdner))
+                continue;
+            return pfad;
+        }
+        return path.join(hermesHome, STANDARD_ORDNER);
+    }
+    async vorbereiten(ort) {
+        const verzeichnis = this.zielVerzeichnis(ort);
+        await mkdir(verzeichnis, { recursive: true });
+        if (ort.art === 'arbeitsverzeichnis') {
+            // .hermes/ darf nicht ins Repo (B7).
+            if (await istGitRepo(ort.pfad))
+                await gitignoreEintragen(ort.pfad, GITIGNORE_ZEILE);
+            return;
+        }
+        await this.registrieren(this.hermesHome(ort), verzeichnis);
+    }
+    /** Trägt das Verzeichnis in skills.external_dirs ein, falls es fehlt. Kommentare bleiben erhalten. */
+    async registrieren(hermesHome, verzeichnis) {
+        const pfad = path.join(hermesHome, CONFIG);
+        const text = await readFile(pfad, 'utf8').catch(() => undefined);
+        const doc = text === undefined ? new Document({ skills: { external_dirs: [] } }) : parseDocument(text);
+        const vorhanden = externalDirs(doc.toJS()).some((e) => this.aufloesen(e, hermesHome) === verzeichnis);
+        if (vorhanden)
+            return;
+        const eintrag = this.alsEintrag(verzeichnis);
+        const liste = doc.getIn(['skills', 'external_dirs']);
+        if (isSeq(liste))
+            liste.add(eintrag);
+        else
+            doc.setIn(['skills', 'external_dirs'], [eintrag]);
+        await mkdir(hermesHome, { recursive: true });
+        await writeFile(pfad, doc.toString());
+    }
+    folgtLinks() {
+        return true;
+    }
+    /** Fähigkeit Profile entdecken: Verzeichnisse mit config.yaml, bei jedem Aufruf frisch gelesen (E19). */
+    async profile() {
+        const basis = path.join(this.home, HERMES_VERZEICHNIS, PROFILE_VERZEICHNIS);
+        const eintraege = await readdir(basis, { withFileTypes: true }).catch(() => []);
+        const namen = [];
+        for (const eintrag of eintraege) {
+            if (!eintrag.isDirectory())
+                continue;
+            const config = await stat(path.join(basis, eintrag.name, CONFIG)).catch(() => undefined);
+            if (config?.isFile())
+                namen.push(eintrag.name);
+        }
+        return namen.sort();
+    }
+}

package/dist/adapter/marketplace-json.js

@@ -0,0 +1,98 @@
+// .claude-plugin/marketplace.json lesen (E24, HARNESS-FAKTEN „Plugins und Marketplaces").
+// Nur die beiden dokumentierten Formen, alles andere wird abgelehnt statt geraten.
+/** Standardordner für die Skills eines Plugins, relativ zu seiner Quelle. */
+const SKILL_ORDNER = 'skills';
+export class MarketplaceUnbekannteForm extends Error {
+    constructor(text) {
+        super(`marketplace.json: ${text}`);
+    }
+}
+/** „./skills/a" und „skills/a/" werden zu „skills/a", „." und „./" zu "". */
+function normalisieren(pfad) {
+    const teile = [];
+    for (const teil of pfad.split('/')) {
+        if (teil === '' || teil === '.')
+            continue;
+        if (teil === '..') {
+            // Dateien außerhalb des Plugin-Verzeichnisses gehören nicht zum Plugin (HARNESS-FAKTEN).
+            throw new MarketplaceUnbekannteForm(`Pfad „${pfad}" führt aus der Quelle heraus`);
+        }
+        teile.push(teil);
+    }
+    return teile.join('/');
+}
+function verbinden(quelle, rest) {
+    const a = normalisieren(quelle);
+    const b = normalisieren(rest);
+    if (a.length === 0)
+        return b;
+    if (b.length === 0)
+        return a;
+    return `${a}/${b}`;
+}
+/** Unterverzeichnisse von `ordner`, die eine SKILL.md enthalten, aus der Dateiliste des Baums. */
+function skillsImOrdner(dateien, ordner) {
+    const praefix = ordner.length === 0 ? '' : `${ordner}/`;
+    const gefunden = new Set();
+    for (const datei of dateien) {
+        if (!datei.startsWith(praefix))
+            continue;
+        const rest = datei.slice(praefix.length).split('/');
+        if (rest.length !== 2 || rest[1] !== 'SKILL.md')
+            continue;
+        gefunden.add(`${praefix}${rest[0]}`);
+    }
+    return [...gefunden].sort();
+}
+function texteLesen(wert, feld) {
+    if (wert === undefined)
+        return [];
+    if (!Array.isArray(wert))
+        throw new MarketplaceUnbekannteForm(`„${feld}" ist keine Liste`);
+    return wert.map((e) => {
+        if (typeof e !== 'string')
+            throw new MarketplaceUnbekannteForm(`„${feld}" enthält einen Eintrag, der kein Text ist`);
+        return e;
+    });
+}
+function pluginLesen(roh, dateien) {
+    if (typeof roh !== 'object' || roh === null || Array.isArray(roh))
+        throw new MarketplaceUnbekannteForm('Ein Eintrag unter „plugins" ist kein Objekt');
+    const eintrag = roh;
+    const name = eintrag['name'];
+    if (typeof name !== 'string' || name.length === 0)
+        throw new MarketplaceUnbekannteForm('Ein Plugin hat keinen Namen');
+    const quelle = eintrag['source'];
+    // Die Doku kennt nur eine Pfadangabe. Fremde Quellen ({ source: "github", … }) und ein
+    // fehlendes Feld lehnt hmgr ab, statt einen Ordner zu raten.
+    if (typeof quelle !== 'string')
+        throw new MarketplaceUnbekannteForm(`Plugin „${name}": „source" ist kein Pfad in dieser Quelle`);
+    const wurzel = normalisieren(quelle);
+    // Mit „skills" gilt genau diese Liste, sonst der Ordner <source>/skills (HARNESS-FAKTEN:
+    // mehrere Plugins teilen sich so einen gemeinsamen skills-Ordner).
+    const genannt = eintrag['skills'];
+    const skills = genannt === undefined
+        ? skillsImOrdner(dateien, verbinden(wurzel, SKILL_ORDNER))
+        : texteLesen(genannt, `Plugin „${name}": skills`).map((p) => verbinden(wurzel, p));
+    return { name, skills, dependencies: texteLesen(eintrag['dependencies'], `Plugin „${name}": dependencies`) };
+}
+/** Liest den Text der marketplace.json. `dateien` ist der Dateibaum der Quelle am selben Ref. */
+export function marketplaceLesen(text, dateien) {
+    let daten;
+    try {
+        daten = JSON.parse(text);
+    }
+    catch (fehler) {
+        throw new MarketplaceUnbekannteForm(`kein gültiges JSON (${fehler instanceof Error ? fehler.message : fehler})`);
+    }
+    if (typeof daten !== 'object' || daten === null || Array.isArray(daten))
+        throw new MarketplaceUnbekannteForm('kein Objekt');
+    const wurzel = daten;
+    const name = wurzel['name'];
+    if (typeof name !== 'string' || name.length === 0)
+        throw new MarketplaceUnbekannteForm('kein „name"');
+    const plugins = wurzel['plugins'];
+    if (!Array.isArray(plugins))
+        throw new MarketplaceUnbekannteForm('kein „plugins" als Liste');
+    return { name, plugins: plugins.map((p) => pluginLesen(p, dateien)) };
+}

package/dist/adapter/quelle-text.js

@@ -0,0 +1,11 @@
+import path from 'node:path';
+/** URL heißt Git-Quelle mit Checkout, ein nackter Pfad heißt lokale Arbeitskopie ohne Clone (B11). */
+export function quelleAusText(text) {
+    const roh = text.trim();
+    if (roh.includes('://') || /^(?:[^@/\s]+@)?[^@/:\s]+:[^/\s]/.test(roh))
+        return { art: 'git', url: roh };
+    return { art: 'lokal', pfad: path.resolve(roh) };
+}
+export function quelleAlsText(quelle) {
+    return quelle.art === 'git' ? quelle.url : quelle.pfad;
+}

package/dist/adapter/skill-md.js

@@ -0,0 +1,49 @@
+// Name eines Skills: `name` aus dem Frontmatter der SKILL.md, sonst der Verzeichnisname (E32).
+import { parse } from 'yaml';
+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');
+    if (zeilen[0]?.trimEnd() !== '---')
+        return undefined;
+    for (let i = 1; i < zeilen.length; i += 1)
+        if (zeilen[i].trimEnd() === '---')
+            return zeilen.slice(1, i).join('\n');
+    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.
+ */
+export function skillName(verzeichnisname, skillMdInhalt) {
+    if (skillMdInhalt === undefined)
+        return verzeichnisname;
+    const block = frontmatter(skillMdInhalt);
+    if (block === undefined)
+        return verzeichnisname;
+    let daten;
+    try {
+        daten = parse(block);
+    }
+    catch {
+        return verzeichnisname;
+    }
+    if (typeof daten !== 'object' || daten === null || Array.isArray(daten))
+        return verzeichnisname;
+    const roh = daten['name'];
+    if (typeof roh !== 'string')
+        return verzeichnisname;
+    const name = roh.trim();
+    if (name.length === 0 || 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 };
+}