hmgr 0.0.1 → 0.0.3

package/README.md

@@ -26,34 +26,5 @@ npm run build
 
 ## 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.
+`hmgr --help` zeigt die Kommandos, `hmgr help <kommando>` Schalter, Beispiele
+und Zusammenhänge.

package/dist/adapter/agents.js

@@ -0,0 +1,43 @@
+// Das universelle Skill-Verzeichnis `.agents/skills`: ein Harness-Typ ohne Programm dahinter (E35).
+// Home ist `~/.agents/skills`, das Arbeitsverzeichnis `<pfad>/.agents/skills`.
+import { mkdir, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { OrtNichtUnterstuetzt } from "../kern/modell.js";
+import { gitignoreEintragen, istGitRepo } from "./gitignore.js";
+const AGENTS_VERZEICHNIS = '.agents';
+const SKILLS_ORDNER = 'skills';
+const GITIGNORE_ZEILE = '.agents/';
+export class Agents {
+    name = 'agents';
+    home;
+    /** `home` ist das HOME des Nutzers, das Verzeichnis liegt darunter als `.agents`. */
+    constructor(home) {
+        this.home = home;
+    }
+    /**
+     * Wie bei den anderen Harness-Typen zählt das angelegte Verzeichnis. Legt es niemand an, gibt es
+     * auf diesem Rechner keinen Konsumenten dafür und `status` überspringt das Ziel.
+     */
+    async vorhanden() {
+        return (await stat(path.join(this.home, AGENTS_VERZEICHNIS)).catch(() => undefined)) !== undefined;
+    }
+    orte() {
+        return ['home', 'arbeitsverzeichnis'];
+    }
+    zielVerzeichnis(ort) {
+        if (ort.art === 'home')
+            return path.join(this.home, AGENTS_VERZEICHNIS, SKILLS_ORDNER);
+        if (ort.art === 'arbeitsverzeichnis')
+            return path.join(ort.pfad, AGENTS_VERZEICHNIS, SKILLS_ORDNER);
+        throw new OrtNichtUnterstuetzt(this.name, ort.art);
+    }
+    async vorbereiten(ort) {
+        await mkdir(this.zielVerzeichnis(ort), { recursive: true });
+        // .agents/ darf nicht ins Repo (B7).
+        if (ort.art === 'arbeitsverzeichnis' && (await istGitRepo(ort.pfad)))
+            await gitignoreEintragen(ort.pfad, GITIGNORE_ZEILE);
+    }
+    folgtLinks() {
+        return true;
+    }
+}

package/dist/adapter/claude-code.js

@@ -120,8 +120,9 @@ class ClaudePlugins {
         const { scope, cwd } = this.scope(ziel);
         await this.rufen(['plugin', 'uninstall', pluginSchluessel({ name: plugin, marketplace }), '--scope', scope], cwd);
     }
+    /** Ohne Namen aktualisiert die CLI alle Marketplaces. Je Plugin verlangt sie einen Namen, das übernimmt hmgr nicht (E14). */
     async aktualisieren() {
-        await this.rufen(['plugin', 'update']);
+        await this.rufen(['plugin', 'marketplace', 'update']);
     }
     /**
      * Die Liste gilt nur für das cwd des Aufrufs und enthält dort alle Scopes. Zum Ort gehören im

package/dist/adapter/hermes.js

@@ -1,6 +1,6 @@
 // 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 { readFileSync, realpathSync } from 'node:fs';
 import { mkdir, readFile, readdir, stat, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { Document, isSeq, parseDocument } from 'yaml';
@@ -29,6 +29,23 @@ function externalDirs(daten) {
         return [];
     return dirs.filter((d) => typeof d === 'string');
 }
+/**
+ * Liest skills.trusted_project_dirs aus einer geparsten config.yaml. Hermes nimmt dort auch einen
+ * einzelnen String, der zählt wie eine Liste mit einem Eintrag.
+ */
+function trustedProjectDirs(daten) {
+    if (typeof daten !== 'object' || daten === null)
+        return [];
+    const skills = daten['skills'];
+    if (typeof skills !== 'object' || skills === null)
+        return [];
+    const dirs = skills['trusted_project_dirs'];
+    if (typeof dirs === 'string')
+        return [dirs];
+    if (!Array.isArray(dirs))
+        return [];
+    return dirs.filter((d) => typeof d === 'string');
+}
 export class Hermes {
     name = 'hermes';
     home;
@@ -125,6 +142,69 @@ export class Hermes {
     folgtLinks() {
         return true;
     }
+    /** Vergleich wie bei Hermes über den aufgelösten Pfad, Symlinks eingeschlossen. */
+    echterPfad(pfad) {
+        try {
+            return realpathSync(path.resolve(pfad));
+        }
+        catch {
+            return path.resolve(pfad);
+        }
+    }
+    /** Steht die Wurzel schon in `skills.trusted_project_dirs` der übergebenen config.yaml. */
+    vertraut(daten, hermesHome, wurzel) {
+        for (const eintrag of trustedProjectDirs(daten)) {
+            const pfad = this.aufloesen(eintrag, hermesHome);
+            if (pfad !== undefined && this.echterPfad(pfad) === wurzel)
+                return true;
+        }
+        return false;
+    }
+    /**
+     * Fähigkeit Hinweis nach dem Link (E34): Hermes lädt `<wurzel>/.hermes/skills` nur, wenn die
+     * Wurzel in `skills.trusted_project_dirs` der config.yaml steht. hmgr trägt sie nicht von sich
+     * aus ein, sondern bietet es als Abhilfe an, entscheiden soll der Nutzer. Maßgeblich ist das
+     * Hermes-Home, ein Profil kennt der Ort Arbeitsverzeichnis nicht. Relative Einträge löst Hermes
+     * gegen das cwd auf, hmgr wie überall gegen das Hermes-Home, in der Praxis stehen dort absolute
+     * Pfade.
+     */
+    async hinweisNachLink(ort) {
+        if (ort.art !== 'arbeitsverzeichnis')
+            return undefined;
+        const hermesHome = path.join(this.home, HERMES_VERZEICHNIS);
+        const wurzel = ort.pfad;
+        if (this.vertraut(this.gelesen(hermesHome), hermesHome, this.echterPfad(wurzel)))
+            return undefined;
+        return {
+            hinweis: `Hermes lädt Projekt-Skills in ${wurzel} erst nach \`hermes skills trust ${wurzel}\`.`,
+            abhilfe: {
+                frage: `Hermes lädt Projekt-Skills in ${wurzel} erst nach Vertrauen. Jetzt als vertrauenswürdig eintragen? [j/N]`,
+                erledigt: `${wurzel} als vertrauenswürdig in Hermes eingetragen.`,
+                ausfuehren: async () => await this.vertrauen(wurzel),
+            },
+        };
+    }
+    /**
+     * Trägt die Wurzel in `skills.trusted_project_dirs` der config.yaml des Hermes-Home ein, falls
+     * sie fehlt. Geschrieben wird der aufgelöste absolute Pfad, so vergleicht Hermes selbst
+     * (HARNESS-FAKTEN). Kommentare bleiben erhalten, ein einzelner String wird zur Liste.
+     */
+    async vertrauen(wurzel) {
+        const hermesHome = path.join(this.home, HERMES_VERZEICHNIS);
+        const pfad = path.join(hermesHome, CONFIG);
+        const text = await readFile(pfad, 'utf8').catch(() => undefined);
+        const doc = text === undefined ? new Document({ skills: { trusted_project_dirs: [] } }) : parseDocument(text);
+        const eintrag = this.echterPfad(wurzel);
+        if (this.vertraut(doc.toJS(), hermesHome, eintrag))
+            return;
+        const liste = doc.getIn(['skills', 'trusted_project_dirs']);
+        if (isSeq(liste))
+            liste.add(eintrag);
+        else
+            doc.setIn(['skills', 'trusted_project_dirs'], [...trustedProjectDirs(doc.toJS()), eintrag]);
+        await mkdir(hermesHome, { recursive: true });
+        await writeFile(pfad, doc.toString());
+    }
     /** 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);

package/dist/adapter/terminal.js

@@ -0,0 +1,24 @@
+// Rückfrage auf dem Terminal. Bleibt dünn: eine Weiche, eine gelesene Zeile, kein eigenes Urteil.
+import { createInterface } from 'node:readline/promises';
+/** Antworten, die als Ja zählen. Alles andere, auch die leere Eingabe, ist Nein. */
+const JA = new Set(['j', 'ja']);
+export class TerminalRueckfrage {
+    /**
+     * Ohne Terminal auf beiden Seiten gibt es niemanden, der antworten könnte: hmgr läuft dann in
+     * einem Composer-Script, einer Pipe oder auf einem Deployment-Rechner (E20). Eine Frage ginge
+     * dort ins Leere und das Lesen von stdin bliebe hängen oder liefe sofort auf das Dateiende. Also
+     * gilt Nein, ohne Ausgabe: der Aufrufer bekommt seinen Hinweis und niemand wartet.
+     */
+    async bestaetigen(frage) {
+        if (process.stdin.isTTY !== true || process.stdout.isTTY !== true)
+            return false;
+        const leser = createInterface({ input: process.stdin, output: process.stdout });
+        try {
+            const antwort = await leser.question(`${frage} `);
+            return JA.has(antwort.trim().toLowerCase());
+        }
+        finally {
+            leser.close();
+        }
+    }
+}

package/dist/cli/hilfe.js

@@ -0,0 +1,254 @@
+// Hilfetexte der CLI. Nur Zeichenketten, keine Ausgabe: die macht main.ts (Terminal-I/O).
+/** Ebene 1: Orientierung, je Kommando ein Einzeiler, Verweis auf die Kommando-Hilfe. */
+export const HILFE = `hmgr verlinkt Skills aus Git-Quellen in die Verzeichnisse, aus denen ein Harness sie lädt:
+claude-code, hermes oder agents. Welche Skills und Plugins zu einem Arbeitsverzeichnis gehören,
+steht in seinem Zeiger, dem extra-Abschnitt einer composer.json.
+
+Arbeitszyklus: Skill in seiner Quelle ändern, committen und pushen, dann hmgr update. Ein frisch
+geklontes Vorhaben holt seinen Stand mit hmgr sync.
+
+hmgr <kommando> [schalter]
+
+  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
+
+hmgr help <kommando> zeigt Schalter, Beispiele und Zusammenhänge.`;
+const SOURCE = `hmgr source add <url|pfad>
+hmgr source list
+
+Eine Quelle ist ein Git-Repo mit Skills. source add prüft, ob sie erreichbar ist, liest ihre Skills
+und ihren Marketplace und merkt sie unter ~/.hmgr. Erst danach kennt hmgr die Skill-Namen, mit
+denen link und plugin add arbeiten. Eine URL wird geklont, ein Pfad bleibt die Arbeitskopie, die
+dort schon liegt, und wird von hmgr nicht verändert.
+
+Schalter: keine.
+
+Beispiele:
+  hmgr source add https://github.com/tim/skills.git
+  hmgr source add ~/.skills/tim-skills
+  hmgr source list
+
+Häufige Fälle:
+  „Skill … liegt in keiner Quelle": die Quelle fehlt, erst source add, dann link.
+  Neue Commits einer bekannten Quelle holt hmgr update, nicht source add.
+
+Siehe auch: hmgr help link, hmgr help plugin, hmgr help update`;
+const DIR = `hmgr dir add <pfad> [--composer <pfad>]
+hmgr dir forget <pfad>
+hmgr dir list
+
+Ein Arbeitsverzeichnis ist ein Verzeichnis, in dem ein Harness gestartet wird. dir add merkt es und
+bindet es an seinen Zeiger, also an die composer.json, in deren extra-Abschnitt Quellen, Skills und
+Plugins des Vorhabens stehen. Ohne Zeiger bleibt das Verzeichnis gemerkt und jeder Link dort lokal
+(E26). dir forget löst Bindung und Eintrag, die gelegten Links bleiben liegen.
+
+Schalter:
+  --composer <pfad>   composer.json wählen, wenn unter dem Verzeichnis mehrere in Frage kommen
+
+Beispiele:
+  hmgr dir add ~/Code/site
+  hmgr dir add ~/Code/site --composer ~/Code/site/app/composer.json
+  hmgr dir list
+
+Häufige Fälle:
+  „Mehrere composer.json unter …": eine mit --composer nennen, hmgr rät nicht.
+  link --ort dir:<pfad> merkt das Verzeichnis von selbst. dir add braucht es vorher nur, wenn die
+  composer.json mehrdeutig ist.
+
+Siehe auch: hmgr help link, hmgr help sync`;
+const LINK = `hmgr link <skill> [schalter]
+
+Legt im Ziel einen Symlink auf den Skill an, der aus einer bekannten Quelle stammt, und trägt ihn
+in den Zeiger des Ziels ein, damit hmgr sync ihn anderswo reproduzieren kann. Einen Zeiger gibt es
+nur für ein Arbeitsverzeichnis mit composer.json, an Home und Profil bleibt jeder Link lokal.
+
+Schalter:
+  --harness <name>    claude-code, hermes oder agents, Standard claude-code
+  --ort <ort>         home, dir:<pfad> oder profil:<name>, Standard home. profil kennt nur hermes
+  --quelle <teil>     Teilstring der Quelle, wenn der Skill-Name in mehreren Quellen vorkommt
+  --version <spanne>  Versionseinschränkung nach Composer-Regeln (etwa ^1.2) oder ein Tag- oder
+                      Branchname. Nur mit Zeiger, also dir:<pfad> ohne --local (E33)
+  --composer <pfad>   composer.json des Arbeitsverzeichnisses, wenn mehrere in Frage kommen
+  --local             Link nur ins Ziel legen, nicht in den Zeiger
+  --ersetzen          einen fremden Eintrag gleichen Namens am Ziel ersetzen
+
+Beispiele:
+  hmgr link netzwerk
+  hmgr link netzwerk --harness hermes --ort profil:researcher
+  hmgr link tq-schema --ort dir:. --version ^2.0
+
+Häufige Fälle:
+  „liegt in mehreren Quellen": mit --quelle <teilstring der URL oder des Pfads> entscheiden.
+  „liegt bereits ein fremder Eintrag": --ersetzen setzen oder vorher hmgr adopt <name>.
+  „gibt es keinen Zeiger": --version braucht ein Arbeitsverzeichnis mit composer.json und kein
+  --local. Ohne Zeiger den Link ohne --version legen.
+
+Siehe auch: hmgr help unlink, hmgr help sync, hmgr help adopt`;
+const UNLINK = `hmgr unlink <skill> [schalter]
+
+Entfernt den Link aus dem Ziel und, wenn das Ziel an einen Zeiger gebunden ist, den Skill aus dem
+Zeiger. Der Checkout unter ~/.hmgr bleibt liegen, Links anderer Ziele bleiben unberührt.
+
+Schalter:
+  --harness <name>    claude-code, hermes oder agents, Standard claude-code
+  --ort <ort>         home, dir:<pfad> oder profil:<name>, Standard home. profil kennt nur hermes
+  --composer <pfad>   composer.json des Arbeitsverzeichnisses, wenn mehrere in Frage kommen
+  --local             nur den Link entfernen, den Eintrag im Zeiger stehen lassen
+
+Beispiele:
+  hmgr unlink netzwerk
+  hmgr unlink netzwerk --ort dir:. --local
+
+Häufige Fälle:
+  Bleibt der Skill im Zeiger stehen, legt hmgr sync ihn wieder an. Ohne --local räumt unlink
+  beides ab.
+
+Siehe auch: hmgr help link, hmgr help sync`;
+const ADOPT = `hmgr adopt [name] [schalter]
+
+Ersetzt fremde Symlinks im Ziel durch eigene hmgr-Links: hmgr liest, aus welcher Git-Arbeitskopie
+ein Link stammt, nimmt deren remote.origin.url als Quelle, legt einen Checkout am selben Branch an
+und verlinkt den Skill daraus. Ohne Namen laufen alle fremden Einträge des Ziels durch, mit Namen
+nur dieser eine. Was sich nicht auflösen lässt, bleibt liegen und wird mit Grund gemeldet.
+
+Schalter:
+  --harness <name>    claude-code, hermes oder agents, Standard claude-code
+  --ort <ort>         home, dir:<pfad> oder profil:<name>, Standard home. profil kennt nur hermes
+  --composer <pfad>   composer.json des Arbeitsverzeichnisses, wenn mehrere in Frage kommen
+  --local             Übernahme nicht in den Zeiger schreiben
+  --probelauf         nur melden, nichts schreiben
+
+Beispiele:
+  hmgr adopt --probelauf
+  hmgr adopt netzwerk --ort dir:.
+
+Häufige Fälle:
+  „kein Symlink": der Eintrag ist ein echtes Verzeichnis, hmgr fasst ihn nicht an.
+  „liegt in keiner Git-Arbeitskopie" oder „ohne remote.origin.url": die Quelle ist nicht
+  bestimmbar. Mit hmgr source add <url> eine Quelle nennen und mit hmgr link --ersetzen verlinken.
+  „ohne Branch (detached HEAD)": in der Arbeitskopie einen Branch auschecken, dann erneut adopt.
+  „Pfad ist in der Quelle kein Skill": im Repo liegt an der Stelle keine SKILL.md.
+
+Siehe auch: hmgr help link, hmgr help status`;
+const PLUGIN = `hmgr plugin add <name> [schalter]
+hmgr plugin remove <name> [schalter]
+hmgr plugin list
+
+Ein Plugin ist ein Bündel aus einem Marketplace, also aus einer Quelle mit
+.claude-plugin/marketplace.json. Hat der Harness die Plugin-Fähigkeit (claude-code), lässt hmgr das
+Plugin von dessen CLI installieren, sonst verlinkt es die flache Skill-Liste des Plugins samt
+seinen Abhängigkeiten. In den Zeiger kommt das Plugin, nicht seine Einzelskills. plugin list zeigt
+die Marketplaces aller bekannten Quellen mit ihren Plugins.
+
+Schalter (add und remove):
+  --harness <name>    claude-code, hermes oder agents, Standard claude-code
+  --ort <ort>         home, dir:<pfad> oder profil:<name>, Standard home. profil kennt nur hermes
+  --composer <pfad>   composer.json des Arbeitsverzeichnisses, wenn mehrere in Frage kommen
+  --local             Plugin nicht in den Zeiger schreiben
+  --quelle <teil>     nur bei add: Quelle eingrenzen, wenn der Name in mehreren Marketplaces steht
+
+Beispiele:
+  hmgr plugin list
+  hmgr plugin add superpowers --ort dir:.
+  hmgr plugin remove superpowers
+
+Häufige Fälle:
+  „Keine Quelle mit Marketplace": erst hmgr source add <url> der Quelle mit der marketplace.json.
+  „liegt in keinem Marketplace der bekannten Quellen": Namen mit hmgr plugin list prüfen.
+  „liegt in mehreren Marketplaces": mit --quelle <teilstring> entscheiden.
+  „braucht …, das im selben Marketplace nicht steht": die Abhängigkeit fehlt im Marketplace, das
+  kann nur die Quelle beheben.
+
+Siehe auch: hmgr help source, hmgr help sync`;
+const SYNC = `hmgr sync [pfad]
+
+Bringt ein Arbeitsverzeichnis auf den Stand seines Zeigers: fehlende Quellen übernehmen, fehlende
+Links legen, Links auf einen anderen Ref umlegen, Plugins herstellen. Ohne Pfad gilt das aktuelle
+Verzeichnis. Das ist der Befehl nach einem frischen Clone eines Vorhabens und nach jeder Änderung
+am Zeiger. Eigene Links, die im Zeiger fehlen, werden als abweichend gemeldet und nicht entfernt,
+fremde Einträge bleiben unberührt.
+
+Schalter: keine.
+
+Beispiele:
+  hmgr sync
+  hmgr sync ~/Code/site
+
+Häufige Fälle:
+  „Kein Zeiger unter …, nichts zu tun": im Verzeichnis liegt keine composer.json. Mit
+  hmgr dir add <pfad> --composer <pfad> eine nennen.
+  „steht nicht im Zeiger": den Link mit hmgr link <skill> --ort dir:<pfad> eintragen oder mit
+  hmgr unlink <skill> --ort dir:<pfad> --local entfernen.
+  „Kein Harness auf diesem Rechner": weder ~/.claude noch ~/.hermes noch ~/.agents ist angelegt.
+
+Siehe auch: hmgr help dir, hmgr help link, hmgr help update`;
+const UPDATE = `hmgr update
+
+Holt für jeden Checkout unter ~/.hmgr den neuesten Stand seines Refs und zieht bei Harnesses mit
+Plugin-Fähigkeit deren Plugins nach (E14). Die Links zeigen weiter auf dieselben Pfade und müssen
+nicht erneuert werden. Ein Checkout mit lokaler Änderung wird übersprungen und gemeldet (E15),
+damit nichts verloren geht. Lokale Quellen haben keinen Checkout und bleiben unberührt.
+
+So wird eine Änderung an einem Skill überall wirksam: in der Quelle committen und pushen, dann
+hmgr update.
+
+Schalter: keine.
+
+Beispiel:
+  hmgr update
+
+Häufige Fälle:
+  „übersprungen … lokale Änderung (E15)": im Checkout liegt eine Änderung, die durch einen Link
+  hindurch gemacht wurde. Dort committen und pushen, dann erneut hmgr update.
+  „Keine Checkouts": es gibt nur lokale Quellen oder noch keinen Link.
+
+Siehe auch: hmgr help sync, hmgr help status`;
+const STATUS = `hmgr status
+
+Liest den Ist-Zustand vom Dateisystem: je Ziel eines vorhandenen Harness die Einträge mit Quelle
+und Ref, davor die Versionseinschränkung, falls der Zeiger eine nennt. Fremde Einträge und Links
+ohne bekannte Quelle sind eigens gekennzeichnet, dazu kommen die Plugins des Ziels. Am Ende stehen
+die Harnesses, die auf diesem Rechner nicht liegen.
+
+Schalter: keine.
+
+Beispiel:
+  hmgr status
+
+Häufige Fälle:
+  „fremd": der Eintrag stammt nicht von hmgr. hmgr adopt <name> übernimmt ihn.
+  „Link ohne bekannte Quelle": der Link zeigt in einen hmgr-Checkout, dessen Quelle nicht mehr im
+  Zustand steht. Mit hmgr source add <url> die Quelle wieder eintragen.
+  „Nicht vorhanden": der Harness hat sein Verzeichnis auf diesem Rechner nicht angelegt, hmgr
+  überspringt seine Ziele.
+
+Siehe auch: hmgr help adopt, hmgr help sync`;
+/** Ebene 2, je Kommandofamilie ein Text. Unterkommandos teilen sich die Hilfe ihrer Familie. */
+const THEMEN = new Map([
+    ['source', SOURCE],
+    ['dir', DIR],
+    ['link', LINK],
+    ['unlink', UNLINK],
+    ['adopt', ADOPT],
+    ['plugin', PLUGIN],
+    ['sync', SYNC],
+    ['update', UPDATE],
+    ['status', STATUS],
+    ['help', HILFE],
+]);
+/** Hilfetext zu einem Kommando, undefined für ein unbekanntes Thema. */
+export function hilfeText(thema) {
+    return THEMEN.get(thema);
+}

package/dist/cli/main.js

@@ -6,13 +6,16 @@ import { homedir } from 'node:os';
 import { pathToFileURL } from 'node:url';
 import { Anwendungsfaelle } from "../kern/anwendungsfaelle.js";
 import { AbhaengigkeitFehlt, EinschraenkungOhneZeiger, HarnessNichtVorhanden, KeinPassenderRef, NameBelegt, OrtNichtUnterstuetzt, PluginMehrdeutig, PluginUnbekannt, SkillMehrdeutig, SkillUnbekannt, ZeigerMehrdeutig, pluginSchluessel, } from "../kern/modell.js";
+import { Agents } from "../adapter/agents.js";
 import { ClaudeCode } from "../adapter/claude-code.js";
 import { Hermes } from "../adapter/hermes.js";
 import { ComposerZeiger } from "../adapter/composer.js";
 import { DateisystemZiele } from "../adapter/dateisystem.js";
 import { GitQuellen } from "../adapter/git.js";
 import { quelleAlsText, quelleAusText } from "../adapter/quelle-text.js";
+import { TerminalRueckfrage } from "../adapter/terminal.js";
 import { ZustandJson } from "../adapter/zustand-json.js";
+import { HILFE, hilfeText } from "./hilfe.js";
 export function umgebungLesen(env = process.env) {
     const home = env.HOME ?? homedir();
     return { home, hmgrHome: env.HMGR_HOME ?? path.join(home, '.hmgr') };
@@ -24,17 +27,18 @@ export function bauen(umgebung, optionen = {}) {
         ? new ClaudeCode(umgebung.home)
         : new ClaudeCode(umgebung.home, optionen.claudeAusfuehrer);
     const ports = {
-        harnesses: [claude, new Hermes(umgebung.home)],
+        harnesses: [claude, new Hermes(umgebung.home), new Agents(umgebung.home)],
         quellen: new GitQuellen(wurzel),
         ziele: new DateisystemZiele(wurzel, zustand),
         zeiger: new ComposerZeiger(),
         zustand,
+        rueckfrage: optionen.rueckfrage ?? new TerminalRueckfrage(),
     };
     return { anwendungsfaelle: new Anwendungsfaelle(ports), ports };
 }
-/** Schalter ohne Wert. Alles andere braucht einen. */
-const FLAGGEN = new Set(['ersetzen', 'local', 'lokal', 'probelauf']);
-function schalterLesen(args) {
+/** Schalter ohne Wert. Alles andere braucht einen. `help` steht hier, damit --help nie greift. */
+const FLAGGEN = new Set(['ersetzen', 'local', 'lokal', 'probelauf', 'help']);
+function schalterLesen(args, kommando) {
     const rest = [];
     const werte = new Map();
     const flaggen = new Set();
@@ -51,7 +55,8 @@ function schalterLesen(args) {
         }
         const wert = args[++i];
         if (wert === undefined)
-            throw new Error(`Schalter --${name} braucht einen Wert`);
+            throw new Error(`Schalter --${name} braucht einen Wert, etwa --${name} <wert>. ` +
+                `${kommando === undefined ? 'hmgr --help' : `hmgr help ${kommando}`} zeigt die Schalter.`);
         werte.set(name, wert);
     }
     return { rest, werte, flaggen };
@@ -66,31 +71,6 @@ function ortLesen(text) {
         return { art: 'profil', name: roh.slice(7) };
     throw new Error(`Unbekannter Ort „${roh}", erwartet home, dir:<pfad> oder profil:<name>`);
 }
-const HILFE = `hmgr <kommando>
-
-  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
-
-  --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 (E33)
-  --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`;
 /** Klartext für den Grund, aus dem ein fremder Eintrag liegen bleibt (B12). */
 const UEBERNAHME_GRUND = {
     'kein-link': 'kein Symlink',
@@ -102,16 +82,36 @@ const UEBERNAHME_GRUND = {
 export async function ausfuehren(argv, umgebung, optionen = {}) {
     const { anwendungsfaelle, ports } = bauen(umgebung, optionen);
     const kommando = argv[0];
-    if (kommando === undefined || kommando === 'help' || kommando === '--help') {
+    // Hilfe zuerst: --help ist überall eine Flagge, damit kein Kommando sie als Wert liest.
+    if (kommando === undefined) {
         console.log(HILFE);
-        return kommando === undefined ? 1 : 0;
+        return 1;
+    }
+    if (kommando === 'help' || kommando === '--help' || kommando === '-h') {
+        const thema = argv[1];
+        if (thema === undefined || thema.startsWith('-')) {
+            console.log(HILFE);
+            return 0;
+        }
+        const text = hilfeText(thema);
+        if (text === undefined)
+            throw new Error(`Unbekanntes Hilfe-Thema „${thema}". hmgr --help zeigt alle Kommandos.`);
+        console.log(text);
+        return 0;
+    }
+    if (argv.slice(1).includes('--help')) {
+        const text = hilfeText(kommando);
+        if (text === undefined)
+            throw new Error(`Unbekanntes Kommando „${kommando}". hmgr --help zeigt alle Kommandos.`);
+        console.log(text);
+        return 0;
     }
     if (kommando === 'source') {
         const unterkommando = argv[1];
         if (unterkommando === 'add') {
             const text = argv[2];
             if (text === undefined)
-                throw new Error('source add braucht eine URL oder einen Pfad');
+                throw new Error('source add braucht eine URL oder einen Pfad, etwa hmgr source add https://example.com/skills.git');
             const quelle = quelleAusText(text);
             const { skills, marketplace } = await anwendungsfaelle.quelleHinzufuegen(quelle);
             console.log(`Quelle ${quelleAlsText(quelle)} (${quelle.art}), ${skills.length} Skills:`);
@@ -134,15 +134,15 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
                 console.log(`${quelle.art}  ${quelleAlsText(quelle)}`);
             return 0;
         }
-        throw new Error('source add <url|pfad> oder source list');
+        throw new Error(`${unterkommando === undefined ? 'source braucht ein Unterkommando' : `Unbekanntes Unterkommando „${unterkommando}" für source`}: source add <url|pfad> oder source list. hmgr help source zeigt Beispiele.`);
     }
     if (kommando === 'dir') {
-        const { rest, werte } = schalterLesen(argv.slice(1));
+        const { rest, werte } = schalterLesen(argv.slice(1), 'dir');
         const unterkommando = rest[0];
         if (unterkommando === 'add') {
             const pfad = rest[1];
             if (pfad === undefined)
-                throw new Error('dir add braucht einen Pfad');
+                throw new Error('dir add braucht einen Pfad, etwa hmgr dir add .');
             const composer = werte.get('composer');
             const ergebnis = composer === undefined
                 ? await anwendungsfaelle.arbeitsverzeichnisHinzufuegen(pfad)
@@ -157,7 +157,7 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
         if (unterkommando === 'forget') {
             const pfad = rest[1];
             if (pfad === undefined)
-                throw new Error('dir forget braucht einen Pfad');
+                throw new Error('dir forget braucht einen Pfad. hmgr dir list zeigt die gemerkten Arbeitsverzeichnisse.');
             await anwendungsfaelle.arbeitsverzeichnisVergessen(pfad);
             console.log(`Arbeitsverzeichnis ${path.resolve(pfad)} vergessen, die Links bleiben liegen.`);
             return 0;
@@ -172,13 +172,14 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
             }
             return 0;
         }
-        throw new Error('dir add <pfad>, dir forget <pfad> oder dir list');
+        throw new Error(`${unterkommando === undefined ? 'dir braucht ein Unterkommando' : `Unbekanntes Unterkommando „${unterkommando}" für dir`}: dir add <pfad>, dir forget <pfad> oder dir list. hmgr help dir zeigt Beispiele.`);
     }
     if (kommando === 'link' || kommando === 'unlink') {
-        const { rest, werte, flaggen } = schalterLesen(argv.slice(1));
+        const { rest, werte, flaggen } = schalterLesen(argv.slice(1), kommando);
         const skill = rest[0];
         if (skill === undefined)
-            throw new Error(`${kommando} braucht einen Skill-Namen`);
+            throw new Error(`${kommando} braucht einen Skill-Namen, etwa hmgr ${kommando} <skill>. ` +
+                'hmgr status zeigt die verlinkten Skills, hmgr source add <url|pfad> die Skills einer Quelle.');
         const ziel = { harness: werte.get('harness') ?? 'claude-code', ort: ortLesen(werte.get('ort')) };
         const lokal = flaggen.has('local') || flaggen.has('lokal');
         if (ziel.ort.art === 'arbeitsverzeichnis') {
@@ -211,7 +212,7 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
         return 0;
     }
     if (kommando === 'adopt') {
-        const { rest, werte, flaggen } = schalterLesen(argv.slice(1));
+        const { rest, werte, flaggen } = schalterLesen(argv.slice(1), 'adopt');
         const ziel = { harness: werte.get('harness') ?? 'claude-code', ort: ortLesen(werte.get('ort')) };
         const probelauf = flaggen.has('probelauf');
         const name = rest[0];
@@ -250,7 +251,7 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
         return 0;
     }
     if (kommando === 'plugin') {
-        const { rest, werte, flaggen } = schalterLesen(argv.slice(1));
+        const { rest, werte, flaggen } = schalterLesen(argv.slice(1), 'plugin');
         const unterkommando = rest[0];
         if (unterkommando === 'list') {
             const marketplaces = await anwendungsfaelle.marketplaces();
@@ -269,10 +270,10 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
             return 0;
         }
         if (unterkommando !== 'add' && unterkommando !== 'remove')
-            throw new Error('plugin add <name>, plugin remove <name> oder plugin list');
+            throw new Error(`${unterkommando === undefined ? 'plugin braucht ein Unterkommando' : `Unbekanntes Unterkommando „${unterkommando}" für plugin`}: plugin add <name>, plugin remove <name> oder plugin list. hmgr help plugin zeigt Beispiele.`);
         const name = rest[1];
         if (name === undefined)
-            throw new Error(`plugin ${unterkommando} braucht einen Plugin-Namen`);
+            throw new Error(`plugin ${unterkommando} braucht einen Plugin-Namen. hmgr plugin list zeigt die Plugins der bekannten Quellen.`);
         const ziel = { harness: werte.get('harness') ?? 'claude-code', ort: ortLesen(werte.get('ort')) };
         const lokal = flaggen.has('local') || flaggen.has('lokal');
         if (ziel.ort.art === 'arbeitsverzeichnis') {
@@ -292,12 +293,14 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
             console.log(`  Skills: ${ergebnis.skills.join(', ')}`);
         if (ergebnis.imZeiger)
             console.log('  im Zeiger vermerkt');
+        // Ein Hinweis kann mehrzeilig sein, jede Zeile bekommt dieselbe Einrückung.
         if (ergebnis.hinweis !== undefined)
-            console.log(`  ${ergebnis.hinweis}`);
+            for (const zeile of ergebnis.hinweis.split('\n'))
+                console.log(`  ${zeile}`);
         return 0;
     }
     if (kommando === 'sync') {
-        const { rest } = schalterLesen(argv.slice(1));
+        const { rest } = schalterLesen(argv.slice(1), 'sync');
         const ergebnis = await anwendungsfaelle.abgleich(rest[0]);
         if (ergebnis.zeigerPfad !== undefined)
             console.log(`Zeiger ${ergebnis.zeigerPfad}`);
@@ -355,7 +358,7 @@ export async function ausfuehren(argv, umgebung, optionen = {}) {
             console.log(`Nicht vorhanden: ${fehlend.join(', ')}`);
         return 0;
     }
-    throw new Error(`Unbekanntes Kommando „${kommando}"`);
+    throw new Error(`Unbekanntes Kommando „${kommando}". hmgr --help zeigt alle Kommandos.`);
 }
 function beschreibeOrt(ort) {
     if (ort.art === 'home')
@@ -377,13 +380,43 @@ function istModellFehler(fehler) {
         fehler instanceof PluginUnbekannt ||
         fehler instanceof AbhaengigkeitFehlt);
 }
+/**
+ * Der nächste Schritt zu einem Fehler aus dem Kern. Die Fehlertexte selbst bleiben, wie das Modell
+ * sie schreibt, die Handlungsanweisung gehört an die CLI, weil sie Kommandos nennt.
+ */
+function naechsterSchritt(fehler) {
+    if (fehler instanceof SkillMehrdeutig)
+        return `Quelle eingrenzen: hmgr link ${fehler.name} --quelle <teilstring einer der genannten Quellen>`;
+    if (fehler instanceof SkillUnbekannt)
+        return 'Erst die Quelle hinzufügen: hmgr source add <url|pfad>. hmgr source list zeigt die bekannten Quellen.';
+    if (fehler instanceof NameBelegt)
+        return `Entweder mit --ersetzen überschreiben oder den fremden Eintrag mit hmgr adopt ${fehler.skillName} übernehmen.`;
+    if (fehler instanceof PluginMehrdeutig)
+        return 'Quelle eingrenzen: --quelle <teilstring der URL oder des Pfads>. hmgr plugin list zeigt die Marketplaces.';
+    if (fehler instanceof PluginUnbekannt)
+        return 'hmgr plugin list zeigt die Plugins der bekannten Quellen. Fehlt der Marketplace, erst hmgr source add <url>.';
+    if (fehler instanceof AbhaengigkeitFehlt)
+        return 'Die Abhängigkeit steht in keinem Plugin desselben Marketplace, das kann nur die Quelle beheben.';
+    if (fehler instanceof KeinPassenderRef)
+        return 'hmgr update holt neue Tags der Quelle. Sonst einen vorhandenen Tag- oder Branchnamen als --version nennen.';
+    if (fehler instanceof HarnessNichtVorhanden)
+        return 'Der Harness legt sein Verzeichnis beim ersten Start an. hmgr status zeigt, welche Harnesses hier liegen.';
+    if (fehler instanceof OrtNichtUnterstuetzt)
+        return 'profil:<name> kennt nur hermes, claude-code und agents kennen home und dir:<pfad>.';
+    const text = fehler instanceof Error ? fehler.message : '';
+    if (text.startsWith('Unbekannter Harness'))
+        return 'Bekannt sind claude-code, hermes und agents.';
+    return undefined;
+}
 export async function main(argv, umgebung) {
     try {
         return await ausfuehren(argv, umgebung);
     }
     catch (fehler) {
         const text = fehler instanceof Error ? fehler.message : String(fehler);
-        console.error(istModellFehler(fehler) ? text : `Fehler: ${text}`);
+        const kopf = istModellFehler(fehler) ? text : `Fehler: ${text}`;
+        const schritt = naechsterSchritt(fehler);
+        console.error(schritt === undefined ? kopf : `${kopf}\n${schritt}`);
         return 1;
     }
 }

package/dist/kern/anwendungsfaelle.js

@@ -11,6 +11,8 @@ function fehlertext(fehler) {
 }
 export class Anwendungsfaelle {
     p;
+    /** Schon beantwortete Orte, je Ziel der Hinweis, der davon übrig blieb (E34). */
+    beantwortet = new Map();
     constructor(p) {
         this.p = p;
     }
@@ -280,19 +282,47 @@ export class Anwendungsfaelle {
         const fund = await this.fundAusZeiger(args.skill, version, args.quelle);
         const link = await this.linkAnlegen(harness, args.ziel, fund, args.ersetzen);
         await this.zeigerErgaenzen(zeigerPfad, fund, version);
-        return link;
+        const hinweis = await this.harnessHinweis(harness, args.ziel.ort);
+        return hinweis === undefined ? link : { ...link, hinweis };
     }
     /** Link legen, wenn Quelle, Ref und Skill schon feststehen. Die Zeiger-Arbeit ist dieselbe. */
     async linkAusFund(harness, ziel, fund, ersetzen, lokal) {
         const link = await this.linkAnlegen(harness, ziel, fund, ersetzen);
-        if (lokal === true || ziel.ort.art !== 'arbeitsverzeichnis')
-            return link;
-        const zeigerPfad = await this.bindungFinden(ziel);
-        // Ziel ohne Zeiger: der Link wird trotzdem gelegt, hmgr weist darauf hin (E26).
-        if (zeigerPfad === undefined)
-            return { ...link, hinweis: `Ohne Zeiger bleibt „${link.name}" lokal, der Link ist gelegt (E26).` };
-        await this.zeigerErgaenzen(zeigerPfad, fund);
-        return link;
+        const hinweise = [];
+        if (lokal !== true && ziel.ort.art === 'arbeitsverzeichnis') {
+            const zeigerPfad = await this.bindungFinden(ziel);
+            // Ziel ohne Zeiger: der Link wird trotzdem gelegt, hmgr weist darauf hin (E26).
+            if (zeigerPfad === undefined)
+                hinweise.push(`Ohne Zeiger bleibt „${link.name}" lokal, der Link ist gelegt (E26).`);
+            else
+                await this.zeigerErgaenzen(zeigerPfad, fund);
+        }
+        const vomHarness = await this.harnessHinweis(harness, ziel.ort);
+        if (vomHarness !== undefined)
+            hinweise.push(vomHarness);
+        return hinweise.length === 0 ? link : { ...link, hinweis: hinweise.join('\n') };
+    }
+    /**
+     * Offener Punkt des Harness zu einem Ort (E34), etwa fehlendes Vertrauen für Projekt-Skills. Ein
+     * Harness ohne diese Fähigkeit schweigt. Nennt der Harness eine Abhilfe, fragt hmgr den Nutzer:
+     * bei Ja leistet der Harness sie und die Ergebniszeile tritt an die Stelle des Hinweises, bei
+     * Nein bleibt es beim Hinweis. Je Lauf und Ziel höchstens eine Frage, die Antwort gilt für den
+     * ganzen Lauf.
+     */
+    async harnessHinweis(harness, ort) {
+        const schluessel = zielSchluessel({ harness: harness.name, ort });
+        if (this.beantwortet.has(schluessel))
+            return this.beantwortet.get(schluessel);
+        const punkt = await harness.hinweisNachLink?.(ort);
+        let hinweis = punkt?.hinweis;
+        const abhilfe = punkt?.abhilfe;
+        if (abhilfe !== undefined && (await this.p.rueckfrage.bestaetigen(abhilfe.frage))) {
+            await abhilfe.ausfuehren();
+            hinweis = abhilfe.erledigt;
+        }
+        if (punkt !== undefined)
+            this.beantwortet.set(schluessel, hinweis);
+        return hinweis;
     }
     /** Link entfernen. Ohne `lokal` verschwindet der Skill auch aus dem Zeiger (E17). */
     async linkEntfernen(args) {
@@ -325,7 +355,15 @@ export class Anwendungsfaelle {
         const skills = await this.flacheSkillListe(fund.plugin.name, fund.quelle);
         for (const skill of skills)
             await this.linkAnlegen(harness, ziel, { quelle: fund.quelle, ref: fund.ref, skill });
-        return { plugin: fund.plugin, art: 'verlinkt', skills: skills.map((s) => s.name), imZeiger: false };
+        // Der Hinweis des Harness gilt dem Ort, also einmal für das ganze Plugin, nicht je Skill (E34).
+        const hinweis = await this.harnessHinweis(harness, ziel.ort);
+        return {
+            plugin: fund.plugin,
+            art: 'verlinkt',
+            skills: skills.map((s) => s.name),
+            imZeiger: false,
+            ...(hinweis === undefined ? {} : { hinweis }),
+        };
     }
     /**
      * Plugin legen (E16, E17, E24, E27). In ein Arbeitsverzeichnis mit Zeiger ist das Plugin
@@ -338,8 +376,11 @@ export class Anwendungsfaelle {
         if (args.lokal === true || args.ziel.ort.art !== 'arbeitsverzeichnis')
             return ergebnis;
         const zeigerPfad = await this.bindungFinden(args.ziel);
-        if (zeigerPfad === undefined)
-            return { ...ergebnis, hinweis: `Ohne Zeiger bleibt „${args.plugin}" lokal, das Plugin liegt am Ziel (E26).` };
+        if (zeigerPfad === undefined) {
+            const ohneZeiger = `Ohne Zeiger bleibt „${args.plugin}" lokal, das Plugin liegt am Ziel (E26).`;
+            const hinweis = ergebnis.hinweis === undefined ? ohneZeiger : `${ohneZeiger}\n${ergebnis.hinweis}`;
+            return { ...ergebnis, hinweis };
+        }
         const zeiger = await this.p.zeiger.lesen(zeigerPfad);
         const key = quelleSchluessel(fund.quelle);
         if (!zeiger.quellen.some((q) => quelleSchluessel(q) === key))
@@ -540,6 +581,10 @@ export class Anwendungsfaelle {
                     continue;
                 ergebnis.abweichend.push(`${harness.name}: ${name} steht nicht im Zeiger`);
             }
+            // Hinweis des Harness zum Ort, einmal je Harness und Lauf, nicht je Skill (E34).
+            const vomHarness = await this.harnessHinweis(harness, ziel.ort);
+            if (vomHarness !== undefined)
+                ergebnis.hinweise.push(vomHarness);
         }
         return ergebnis;
     }

package/dist/ports/rueckfrage.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hmgr",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Harness Manager: Skills und Plugins für AI-Harnesses verwalten",
   "license": "MIT",
   "author": "Tim Kaufmann",
@@ -31,5 +31,9 @@
     "@types/node": "^24.0.0",
     "typescript": "^5.9.0",
     "vitest": "^3.2.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitea.timkaufmann.de/tim/hmgr.git"
   }
 }