hmgr 0.0.1 → 0.0.2

package/README.md

@@ -46,7 +46,7 @@ status                  Ist-Zustand der Ziele
 Optionen:
 
 ```
---harness <name>        claude-code oder hermes, Standard claude-code
+--harness <name>        claude-code, hermes oder agents, 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

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/main.js

@@ -6,12 +6,14 @@ 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";
 export function umgebungLesen(env = process.env) {
     const home = env.HOME ?? homedir();
@@ -24,11 +26,12 @@ 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 };
 }
@@ -83,7 +86,7 @@ const HILFE = `hmgr <kommando>
   update                  Alle Checkouts aktualisieren
   status                  Ist-Zustand der Ziele
 
-  --harness <name>        claude-code oder hermes, Standard claude-code
+  --harness <name>        claude-code, hermes oder agents, 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)
@@ -292,8 +295,10 @@ 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') {

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.2",
   "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"
   }
 }