hmgr 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tim Kaufmann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,59 @@
+# hmgr
+
+hmgr verwaltet Skills und Plugins für AI-Harnesses auf den Rechnern eines Nutzers. Ein Harness ist ein Agentenprogramm, das Skills aus Verzeichnissen lädt, derzeit Claude Code und Hermes Agent. hmgr holt Skills aus Quellen, legt sie als Links in Ziele (Harness plus Ort, also Home, Profil oder Arbeitsverzeichnis) und hält sie aktuell. Welche Skills und Plugins zu einem Ziel gehören, steht in einem Zeiger, der an das Ziel gebunden ist.
+
+## Installation
+
+Das Paket liegt öffentlich auf npmjs, es enthält nur `dist/` und diese README.
+
+```
+npm install -g hmgr
+```
+
+Danach steht das Kommando `hmgr` bereit. Aus dem Repo geht es auch ohne Registry: `npm pack` baut `dist/` und packt es, `npm install -g hmgr-0.0.1.tgz` installiert das Tarball.
+
+## Entwicklung
+
+Node ab 22.6, weil im Entwicklungsmodus `.ts` direkt ausgeführt wird.
+
+```
+npm run dev -- <kommando>
+npm test
+npm run build
+```
+
+`npm run dev` startet `src/cli/main.ts`, `npm run build` erzeugt `dist/`.
+
+## Kommandos
+
+```
+source add <url|pfad>   Quelle hinzufügen (URL wird geklont, Pfad bleibt Arbeitskopie)
+source list             Quellen zeigen
+dir add <pfad>          Arbeitsverzeichnis merken und an seinen Zeiger binden
+dir forget <pfad>       Arbeitsverzeichnis und Bindung vergessen, Links bleiben
+dir list                Arbeitsverzeichnisse mit ihrer Bindung zeigen
+link <skill>            Skill in ein Ziel verlinken
+unlink <skill>          Link entfernen
+adopt [name]            Fremde Links im Ziel durch eigene hmgr-Links ersetzen
+plugin add <name>       Plugin in ein Ziel legen (installieren oder Skills verlinken)
+plugin remove <name>    Plugin aus einem Ziel entfernen
+plugin list             Plugins der Marketplaces aller Quellen
+sync [pfad]             Ziel auf den Stand seines Zeigers bringen
+update                  Alle Checkouts aktualisieren
+status                  Ist-Zustand der Ziele
+```
+
+Optionen:
+
+```
+--harness <name>        claude-code oder hermes, Standard claude-code
+--ort home|dir:<pfad>|profil:<name>   Standard home
+--quelle <teilstring>   Quelle bei mehrdeutigem Skill-Namen
+--version <spanne>      Versionseinschränkung nach Composer-Regeln, nur mit Zeiger
+--composer <pfad>       composer.json wählen, wenn mehrere in Frage kommen
+--local                 Link nur ins Ziel legen, nicht in den Zeiger
+--ersetzen              fremden Eintrag am Ziel ersetzen
+--probelauf             bei adopt nur melden, nichts schreiben
+```
+
+`hmgr help` zeigt dieselbe Übersicht.

package/dist/adapter/checkout-pfad.js

@@ -0,0 +1,66 @@
+// Pfadschema der Checkouts (E22): <wurzel>/<host>/<besitzer>/<repo>/<ref>/,
+// je Repo ein Basis-Clone unter <wurzel>/<host>/<besitzer>/<repo>/.repo.
+import path from 'node:path';
+export const BASIS_NAME = '.repo';
+/** Refs mit „/" im Namen werden im Pfad kodiert, damit ein Ref ein Verzeichnis bleibt. */
+export function refKodieren(ref) {
+    return ref.replaceAll('%', '%25').replaceAll('/', '%2F');
+}
+export function refDekodieren(text) {
+    return text.replaceAll('%2F', '/').replaceAll('%25', '%');
+}
+function ohneGitSuffix(name) {
+    return name.endsWith('.git') ? name.slice(0, -4) : name;
+}
+function ausSegmenten(host, segmente) {
+    const gefiltert = segmente.filter((s) => s.length > 0);
+    const repo = ohneGitSuffix(gefiltert[gefiltert.length - 1] ?? 'repo');
+    const besitzer = gefiltert[gefiltert.length - 2] ?? '_';
+    return { host, besitzer, repo };
+}
+/** Zerlegt „git@host:besitzer/repo.git", „https://host/besitzer/repo", „file:///pfad" und nackte Pfade. */
+export function urlZerlegen(url) {
+    const text = url.trim().replace(/\/+$/, '');
+    if (text.includes('://')) {
+        const u = new URL(text);
+        if (u.protocol === 'file:')
+            return ausSegmenten('local', decodeURIComponent(u.pathname).split('/'));
+        return ausSegmenten(u.hostname, decodeURIComponent(u.pathname).split('/'));
+    }
+    const scp = /^(?:[^@/]+@)?([^@/:]+):(.+)$/.exec(text);
+    if (scp)
+        return ausSegmenten(scp[1], scp[2].split('/'));
+    // Nackter lokaler Pfad: Besitzer aus dem Elternverzeichnis.
+    return ausSegmenten('local', path.resolve(text).split(path.sep));
+}
+export function quelleZerlegen(quelle) {
+    return urlZerlegen(quelle.art === 'git' ? quelle.url : quelle.pfad);
+}
+export function repoPfad(wurzel, ort) {
+    return path.join(wurzel, ort.host, ort.besitzer, ort.repo);
+}
+export function basisPfad(wurzel, ort) {
+    return path.join(repoPfad(wurzel, ort), BASIS_NAME);
+}
+export function worktreePfad(wurzel, ort, ref) {
+    return path.join(repoPfad(wurzel, ort), refKodieren(ref));
+}
+/** Liest aus einem Pfad unter der Wurzel Host, Besitzer, Repo, Ref und den Skill-Pfad zurück (E22). */
+export function checkoutZerlegen(wurzel, pfad) {
+    const rel = path.relative(path.resolve(wurzel), path.resolve(pfad));
+    if (rel.startsWith('..') || path.isAbsolute(rel) || rel.length === 0)
+        return undefined;
+    const teile = rel.split(path.sep);
+    if (teile.length < 4)
+        return undefined;
+    const [host, besitzer, repo, refTeil, ...rest] = teile;
+    if (refTeil === BASIS_NAME)
+        return undefined;
+    const ort = { host, besitzer, repo };
+    return {
+        ort,
+        ref: refDekodieren(refTeil),
+        checkoutPfad: worktreePfad(wurzel, ort, refDekodieren(refTeil)),
+        skillPfad: rest.join('/'),
+    };
+}

package/dist/adapter/claude-code.js

@@ -0,0 +1,184 @@
+// Claude Code: Grundverhalten plus Plugins über die claude-CLI (E16, E24, E27).
+import { execFile } from 'node:child_process';
+import { mkdir, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { OrtNichtUnterstuetzt, pluginSchluessel } from "../kern/modell.js";
+import { gitignoreEintragen, istGitRepo } from "./gitignore.js";
+const GITIGNORE_ZEILE = '.claude/';
+const ausfuehrenRoh = promisify(execFile);
+/** Standard-Ausführer: `claude` vom PATH. Ein Fehlschlag wird zum Code, nicht zur Ausnahme. */
+export const claudeAusfuehrer = async (args, cwd) => {
+    try {
+        const { stdout } = await ausfuehrenRoh('claude', args, {
+            ...(cwd === undefined ? {} : { cwd }),
+            maxBuffer: 32 * 1024 * 1024,
+        });
+        return { stdout, code: 0 };
+    }
+    catch (fehler) {
+        const f = fehler;
+        return { stdout: `${f.stdout ?? ''}${f.stderr ?? ''}`, code: typeof f.code === 'number' ? f.code : 1 };
+    }
+};
+export class PluginListeUnbekannteForm extends Error {
+    constructor(text) {
+        super(`claude plugin list --json: ${text}`);
+    }
+}
+function istScope(wert) {
+    return wert === 'user' || wert === 'project' || wert === 'local';
+}
+/**
+ * `claude plugin list --json` liefert ein Array, je Eintrag `id` als „plugin@marketplace" und
+ * `scope` als user, project oder local. Alles andere wird abgelehnt statt geraten.
+ * Format geprüft gegen Claude Code 2.1.251 am 2026-08-30.
+ */
+export function pluginListeLesen(text) {
+    let daten;
+    try {
+        daten = JSON.parse(text);
+    }
+    catch {
+        throw new PluginListeUnbekannteForm('kein JSON');
+    }
+    if (!Array.isArray(daten))
+        throw new PluginListeUnbekannteForm('kein Array');
+    return daten.map((roh) => {
+        if (typeof roh !== 'object' || roh === null || Array.isArray(roh))
+            throw new PluginListeUnbekannteForm('ein Eintrag ist kein Objekt');
+        const o = roh;
+        const id = o['id'];
+        if (typeof id !== 'string')
+            throw new PluginListeUnbekannteForm('ein Eintrag hat kein Feld „id"');
+        const trenner = id.lastIndexOf('@');
+        if (trenner <= 0 || trenner === id.length - 1)
+            throw new PluginListeUnbekannteForm(`„${id}" ist kein „plugin@marketplace"`);
+        const scope = o['scope'];
+        if (!istScope(scope))
+            throw new PluginListeUnbekannteForm(`„${id}" hat keinen bekannten Scope`);
+        return { name: id.slice(0, trenner), marketplace: id.slice(trenner + 1), scope };
+    });
+}
+/**
+ * `claude plugin marketplace list` schreibt je Marketplace eine mit `❯` eingeleitete Namenszeile,
+ * darunter eingerückt „Source: …". Nur die Namenszeilen zählen, die Source-Zeile nicht.
+ * Format geprüft gegen Claude Code 2.1.251 am 2026-08-30.
+ */
+export function marketplaceListeLesen(text) {
+    const namen = [];
+    for (const zeile of text.split('\n')) {
+        const treffer = /^ *❯ +(.+)$/.exec(zeile);
+        if (treffer !== null)
+            namen.push(treffer[1].trim());
+    }
+    return namen;
+}
+/**
+ * Plugins über `claude plugin …`. Scope ist immer `local` mit dem Arbeitsverzeichnis selbst als
+ * cwd (E27). Nur das Home des Nutzers läuft als `--scope user` ohne cwd.
+ */
+class ClaudePlugins {
+    harness;
+    ausfuehrer;
+    constructor(harness, ausfuehrer) {
+        this.harness = harness;
+        this.ausfuehrer = ausfuehrer;
+    }
+    async rufen(args, cwd) {
+        const { stdout, code } = await this.ausfuehrer(args, cwd);
+        if (code !== 0)
+            throw new Error(`claude ${args.join(' ')} scheiterte (Code ${code}): ${stdout.trim()}`);
+        return stdout;
+    }
+    /**
+     * Scope und cwd eines Ortes (E27). Das cwd ist das Arbeitsverzeichnis selbst, nicht sein
+     * Zielverzeichnis: außerhalb eines Git-Repos legt Claude Code die `settings.local.json` im
+     * Startverzeichnis ab, mit dem Zielverzeichnis als cwd landete sie unter `.claude/skills/`.
+     */
+    scope(ziel) {
+        if (ziel.ort.art === 'home')
+            return { scope: 'user' };
+        if (ziel.ort.art === 'arbeitsverzeichnis')
+            return { scope: 'local', cwd: ziel.ort.pfad };
+        throw new OrtNichtUnterstuetzt(this.harness.name, ziel.ort.art);
+    }
+    async marketplaceBekannt(name) {
+        const { stdout, code } = await this.ausfuehrer(['plugin', 'marketplace', 'list']);
+        if (code !== 0)
+            return false;
+        return marketplaceListeLesen(stdout).includes(name);
+    }
+    async marketplaceHinzufuegen(_name, url) {
+        await this.rufen(['plugin', 'marketplace', 'add', url]);
+    }
+    async installieren(plugin, marketplace, ziel) {
+        const { scope, cwd } = this.scope(ziel);
+        await this.rufen(['plugin', 'install', pluginSchluessel({ name: plugin, marketplace }), '--scope', scope], cwd);
+    }
+    async entfernen(plugin, marketplace, ziel) {
+        const { scope, cwd } = this.scope(ziel);
+        await this.rufen(['plugin', 'uninstall', pluginSchluessel({ name: plugin, marketplace }), '--scope', scope], cwd);
+    }
+    async aktualisieren() {
+        await this.rufen(['plugin', 'update']);
+    }
+    /**
+     * Die Liste gilt nur für das cwd des Aufrufs und enthält dort alle Scopes. Zum Ort gehören im
+     * Home die Plugins mit Scope `user`, im Arbeitsverzeichnis die mit `local` und `project`.
+     */
+    async installierte(ziel) {
+        const { cwd } = this.scope(ziel);
+        const { stdout, code } = await this.ausfuehrer(['plugin', 'list', '--json'], cwd);
+        if (code !== 0)
+            return [];
+        const erlaubt = ziel.ort.art === 'home' ? ['user'] : ['local', 'project'];
+        return pluginListeLesen(stdout)
+            .filter((eintrag) => erlaubt.includes(eintrag.scope))
+            .map((eintrag) => pluginSchluessel(eintrag));
+    }
+}
+export class ClaudeCode {
+    name = 'claude-code';
+    home;
+    ausfuehrer;
+    /** Wird von `vorhanden()` gesetzt, sobald die claude-CLI auf dem PATH liegt. */
+    plugins;
+    geprueft = false;
+    constructor(home, ausfuehrer = claudeAusfuehrer) {
+        this.home = home;
+        this.ausfuehrer = ausfuehrer;
+    }
+    /**
+     * Claude Code liegt auf dem Rechner, wenn es sein Home angelegt hat. Die Plugin-Fähigkeit
+     * kommt dazu, sobald `claude --version` durchläuft: ohne CLI gibt es keine Plugins.
+     */
+    async vorhanden() {
+        const da = (await stat(path.join(this.home, '.claude')).catch(() => undefined)) !== undefined;
+        if (!this.geprueft) {
+            this.geprueft = true;
+            const { code } = await this.ausfuehrer(['--version']).catch(() => ({ code: 1 }));
+            if (code === 0)
+                this.plugins = new ClaudePlugins(this, this.ausfuehrer);
+        }
+        return da;
+    }
+    orte() {
+        return ['home', 'arbeitsverzeichnis'];
+    }
+    zielVerzeichnis(ort) {
+        if (ort.art === 'home')
+            return path.join(this.home, '.claude', 'skills');
+        if (ort.art === 'arbeitsverzeichnis')
+            return path.join(ort.pfad, '.claude', 'skills');
+        throw new OrtNichtUnterstuetzt(this.name, ort.art);
+    }
+    async vorbereiten(ort) {
+        await mkdir(this.zielVerzeichnis(ort), { recursive: true });
+        if (ort.art === 'arbeitsverzeichnis' && (await istGitRepo(ort.pfad)))
+            await gitignoreEintragen(ort.pfad, GITIGNORE_ZEILE);
+    }
+    folgtLinks() {
+        return true;
+    }
+}

package/dist/adapter/composer.js

@@ -0,0 +1,94 @@
+// Zeiger in der composer.json des Repos, unter extra.hmgr (B8, E25, E26).
+import { readFile, readdir, stat, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { quelleAusText } from "./quelle-text.js";
+const DATEI = 'composer.json';
+/** Ruft hmgr nur auf, wenn es vorhanden ist, und lässt composer nie scheitern (E20). */
+export const SCRIPT_EINTRAG = 'command -v hmgr >/dev/null 2>&1 && hmgr sync || true';
+const SCRIPT_SCHLUESSEL = ['post-install-cmd', 'post-update-cmd'];
+async function istDatei(pfad) {
+    const info = await stat(pfad).catch(() => undefined);
+    return info !== undefined && info.isFile();
+}
+function quelleAusEintrag(eintrag, verzeichnis) {
+    if (typeof eintrag === 'string')
+        return quelleAusText(eintrag);
+    return { art: 'lokal', pfad: path.resolve(verzeichnis, eintrag.path) };
+}
+function quelleAlsEintrag(quelle) {
+    return quelle.art === 'git' ? quelle.url : { path: quelle.pfad };
+}
+export class ComposerZeiger {
+    async finden(verzeichnis) {
+        const eigen = path.join(verzeichnis, DATEI);
+        if (await istDatei(eigen))
+            return { ergebnis: 'gefunden', pfad: eigen };
+        const eintraege = await readdir(verzeichnis, { withFileTypes: true }).catch(() => []);
+        const kandidaten = [];
+        for (const eintrag of eintraege) {
+            if (!eintrag.isDirectory())
+                continue;
+            const pfad = path.join(verzeichnis, eintrag.name, DATEI);
+            if (await istDatei(pfad))
+                kandidaten.push(pfad);
+        }
+        kandidaten.sort();
+        if (kandidaten.length === 1)
+            return { ergebnis: 'gefunden', pfad: kandidaten[0] };
+        if (kandidaten.length === 0)
+            return { ergebnis: 'keiner' };
+        return { ergebnis: 'mehrdeutig', kandidaten };
+    }
+    async lesen(pfad) {
+        const daten = JSON.parse(await readFile(pfad, 'utf8'));
+        const eintrag = daten.extra?.hmgr ?? {};
+        const verzeichnis = path.dirname(pfad);
+        return {
+            quellen: (eintrag.sources ?? []).map((q) => quelleAusEintrag(q, verzeichnis)),
+            skills: new Map(Object.entries(eintrag.skills ?? {})),
+            plugins: eintrag.plugins ?? [],
+        };
+    }
+    async schreiben(pfad, zeiger) {
+        const daten = JSON.parse(await readFile(pfad, 'utf8'));
+        const eintrag = {
+            sources: zeiger.quellen.map(quelleAlsEintrag),
+            skills: Object.fromEntries(zeiger.skills),
+            plugins: zeiger.plugins,
+        };
+        daten.extra = { ...(daten.extra ?? {}), hmgr: eintrag };
+        await writeFile(pfad, `${JSON.stringify(daten, null, 4)}\n`);
+    }
+    /**
+     * Trägt den hmgr-Aufruf in post-install-cmd und post-update-cmd ein (E20). Bestehende Einträge
+     * und ihre Reihenfolge bleiben, der Rest der Datei bleibt unberührt. Idempotent.
+     */
+    async scriptEintragen(pfad) {
+        const daten = JSON.parse(await readFile(pfad, 'utf8'));
+        const scripts = { ...(daten.scripts ?? {}) };
+        let geaendert = false;
+        for (const schluessel of SCRIPT_SCHLUESSEL) {
+            const vorher = scripts[schluessel];
+            if (vorher === undefined) {
+                scripts[schluessel] = [SCRIPT_EINTRAG];
+                geaendert = true;
+            }
+            else if (typeof vorher === 'string') {
+                if (vorher === SCRIPT_EINTRAG)
+                    continue;
+                scripts[schluessel] = [vorher, SCRIPT_EINTRAG];
+                geaendert = true;
+            }
+            else if (Array.isArray(vorher)) {
+                if (vorher.includes(SCRIPT_EINTRAG))
+                    continue;
+                scripts[schluessel] = [...vorher, SCRIPT_EINTRAG];
+                geaendert = true;
+            }
+        }
+        if (!geaendert)
+            return;
+        daten.scripts = scripts;
+        await writeFile(pfad, `${JSON.stringify(daten, null, 4)}\n`);
+    }
+}

package/dist/adapter/dateisystem.js

@@ -0,0 +1,126 @@
+// Ziele im Dateisystem: Links legen, lesen und entfernen. Fremde Einträge bleiben unangetastet (E12).
+import { lstat, mkdir, readFile, readdir, readlink, rm, stat, symlink, unlink } from 'node:fs/promises';
+import path from 'node:path';
+import { NameBelegt } from "../kern/modell.js";
+import { checkoutZerlegen, quelleZerlegen } from "./checkout-pfad.js";
+import { LOKAL_REF } from "./git.js";
+import { SKILL_DATEI, skillName } from "./skill-md.js";
+export class DateisystemZiele {
+    wurzel;
+    zustand;
+    constructor(wurzel, zustand) {
+        this.wurzel = wurzel;
+        this.zustand = zustand;
+    }
+    async quellen() {
+        return (await this.zustand.lesen()).quellen;
+    }
+    /**
+     * Der Skill hinter einem Linkziel. Der Name kommt aus der SKILL.md am Linkziel, nicht aus dem
+     * Namen des Eintrags im Ziel: derselbe Skill soll überall gleich heißen, auch wenn ein Eintrag
+     * von Hand umbenannt wurde (E32).
+     */
+    async skill(zielPfad, skillPfad, ersatz) {
+        const verzeichnisname = skillPfad.split('/').filter((t) => t.length > 0).at(-1) ?? ersatz;
+        const inhalt = await readFile(path.join(zielPfad, SKILL_DATEI), 'utf8').catch(() => undefined);
+        return { name: skillName(verzeichnisname, inhalt), pfad: skillPfad };
+    }
+    /** Liest aus dem Linkziel Quelle, Ref und Skill zurück. Undefined heißt: kein eigener Link. */
+    async deuten(zielPfad) {
+        const quellen = await this.quellen();
+        const teile = checkoutZerlegen(this.wurzel, zielPfad);
+        if (teile) {
+            const bekannt = quellen.find((q) => {
+                const o = quelleZerlegen(q);
+                return (q.art === 'git' && o.host === teile.ort.host && o.besitzer === teile.ort.besitzer && o.repo === teile.ort.repo);
+            });
+            // Ohne bekannte Quelle bleibt es ein eigener Link, dessen Quelle unbekannt ist. Keine URL raten.
+            if (!bekannt)
+                return { art: 'link-ohne-quelle', checkoutPfad: teile.checkoutPfad };
+            return {
+                art: 'link',
+                checkout: { quelle: bekannt, ref: teile.ref, pfad: teile.checkoutPfad },
+                skill: await this.skill(zielPfad, teile.skillPfad, teile.ort.repo),
+            };
+        }
+        // Außerhalb der Wurzel: nur bekannte lokale Quellen sind eigene Links (B11).
+        for (const quelle of quellen) {
+            if (quelle.art !== 'lokal')
+                continue;
+            const basis = path.resolve(quelle.pfad);
+            const rel = path.relative(basis, zielPfad);
+            if (rel.startsWith('..') || path.isAbsolute(rel))
+                continue;
+            const skillPfad = rel.split(path.sep).join('/');
+            return {
+                art: 'link',
+                checkout: { quelle, ref: LOKAL_REF, pfad: basis },
+                skill: await this.skill(zielPfad, skillPfad, path.basename(basis)),
+            };
+        }
+        return undefined;
+    }
+    async linkZiel(verzeichnis, name) {
+        const pfad = path.join(verzeichnis, name);
+        const info = await lstat(pfad).catch(() => undefined);
+        if (!info || !info.isSymbolicLink())
+            return undefined;
+        return path.resolve(verzeichnis, await readlink(pfad));
+    }
+    /**
+     * Ein Skill ist ein Verzeichnis. Dateien wie .DS_Store zählen nicht als fremder Eintrag,
+     * ebenso wenig ein Symlink, der auf keine Verzeichnis zeigt.
+     */
+    async istVerzeichnis(verzeichnis, name) {
+        const pfad = path.join(verzeichnis, name);
+        const info = await lstat(pfad).catch(() => undefined);
+        if (info === undefined)
+            return false;
+        if (info.isDirectory())
+            return true;
+        if (!info.isSymbolicLink())
+            return false;
+        return (await stat(pfad).catch(() => undefined))?.isDirectory() === true;
+    }
+    async eintraege(ziel, verzeichnis) {
+        const namen = await readdir(verzeichnis).catch(() => []);
+        const ergebnis = [];
+        for (const name of namen.sort()) {
+            if (!(await this.istVerzeichnis(verzeichnis, name)))
+                continue;
+            const zielPfad = await this.linkZiel(verzeichnis, name);
+            const gedeutet = zielPfad ? await this.deuten(zielPfad) : undefined;
+            if (gedeutet?.art === 'link')
+                ergebnis.push({ art: 'link', link: { ziel, name, checkout: gedeutet.checkout, skill: gedeutet.skill } });
+            else if (gedeutet)
+                ergebnis.push({ art: 'link-ohne-quelle', name, checkoutPfad: gedeutet.checkoutPfad });
+            // Ist der fremde Eintrag ein Symlink, wandert sein Ziel mit: darauf setzt die Übernahme auf (B12).
+            else
+                ergebnis.push({ art: 'fremd', name, ...(zielPfad === undefined ? {} : { linkZiel: zielPfad }) });
+        }
+        return ergebnis;
+    }
+    async linkLegen(ziel, verzeichnis, name, checkout, skill, ersetzen) {
+        await mkdir(verzeichnis, { recursive: true });
+        const pfad = path.join(verzeichnis, name);
+        const info = await lstat(pfad).catch(() => undefined);
+        if (info) {
+            const zielPfad = await this.linkZiel(verzeichnis, name);
+            const eigen = zielPfad ? await this.deuten(zielPfad) : undefined;
+            if (eigen)
+                await unlink(pfad);
+            else if (ersetzen)
+                await rm(pfad, { recursive: true, force: true });
+            else
+                throw new NameBelegt(ziel, name);
+        }
+        await symlink(path.join(checkout.pfad, skill.pfad), pfad);
+    }
+    async linkEntfernen(_ziel, verzeichnis, name) {
+        const zielPfad = await this.linkZiel(verzeichnis, name);
+        if (!zielPfad)
+            return;
+        if (await this.deuten(zielPfad))
+            await unlink(path.join(verzeichnis, name));
+    }
+}