hmgr 0.0.1

package/dist/adapter/zustand-json.js

@@ -0,0 +1,25 @@
+// Lokaler Zustand als eine JSON-Datei, Standard ~/.hmgr/state.json (E29).
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { leererZustand } from "../ports/zustand.js";
+export class ZustandJson {
+    pfad;
+    constructor(pfad) {
+        this.pfad = pfad;
+    }
+    async lesen() {
+        const roh = await readFile(this.pfad, 'utf8').catch(() => undefined);
+        if (roh === undefined)
+            return leererZustand();
+        const daten = JSON.parse(roh);
+        return {
+            quellen: (daten.quellen ?? []),
+            arbeitsverzeichnisse: (daten.arbeitsverzeichnisse ?? []),
+            bindungen: (daten.bindungen ?? []),
+        };
+    }
+    async schreiben(zustand) {
+        await mkdir(path.dirname(this.pfad), { recursive: true });
+        await writeFile(this.pfad, `${JSON.stringify(zustand, null, 2)}\n`);
+    }
+}

package/dist/cli/main.js

@@ -0,0 +1,407 @@
+#!/usr/bin/env node
+// hmgr-CLI ohne Bibliothek: argv von Hand, ein kleines Kommando.
+import path from 'node:path';
+import { realpathSync } from 'node:fs';
+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 { 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 { ZustandJson } from "../adapter/zustand-json.js";
+export function umgebungLesen(env = process.env) {
+    const home = env.HOME ?? homedir();
+    return { home, hmgrHome: env.HMGR_HOME ?? path.join(home, '.hmgr') };
+}
+export function bauen(umgebung, optionen = {}) {
+    const zustand = new ZustandJson(path.join(umgebung.hmgrHome, 'state.json'));
+    const wurzel = path.join(umgebung.hmgrHome, 'checkouts');
+    const claude = optionen.claudeAusfuehrer === undefined
+        ? new ClaudeCode(umgebung.home)
+        : new ClaudeCode(umgebung.home, optionen.claudeAusfuehrer);
+    const ports = {
+        harnesses: [claude, new Hermes(umgebung.home)],
+        quellen: new GitQuellen(wurzel),
+        ziele: new DateisystemZiele(wurzel, zustand),
+        zeiger: new ComposerZeiger(),
+        zustand,
+    };
+    return { anwendungsfaelle: new Anwendungsfaelle(ports), ports };
+}
+/** Schalter ohne Wert. Alles andere braucht einen. */
+const FLAGGEN = new Set(['ersetzen', 'local', 'lokal', 'probelauf']);
+function schalterLesen(args) {
+    const rest = [];
+    const werte = new Map();
+    const flaggen = new Set();
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (!arg.startsWith('--')) {
+            rest.push(arg);
+            continue;
+        }
+        const name = arg.slice(2);
+        if (FLAGGEN.has(name)) {
+            flaggen.add(name);
+            continue;
+        }
+        const wert = args[++i];
+        if (wert === undefined)
+            throw new Error(`Schalter --${name} braucht einen Wert`);
+        werte.set(name, wert);
+    }
+    return { rest, werte, flaggen };
+}
+function ortLesen(text) {
+    const roh = text ?? 'home';
+    if (roh === 'home')
+        return { art: 'home' };
+    if (roh.startsWith('dir:'))
+        return { art: 'arbeitsverzeichnis', pfad: path.resolve(roh.slice(4)) };
+    if (roh.startsWith('profil:'))
+        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',
+    'keine-arbeitskopie': 'liegt in keiner Git-Arbeitskopie',
+    'keine-url': 'Arbeitskopie ohne remote.origin.url',
+    'kein-branch': 'Arbeitskopie ohne Branch (detached HEAD)',
+    'skill-unbekannt': 'Pfad ist in der Quelle kein Skill',
+};
+export async function ausfuehren(argv, umgebung, optionen = {}) {
+    const { anwendungsfaelle, ports } = bauen(umgebung, optionen);
+    const kommando = argv[0];
+    if (kommando === undefined || kommando === 'help' || kommando === '--help') {
+        console.log(HILFE);
+        return kommando === undefined ? 1 : 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');
+            const quelle = quelleAusText(text);
+            const { skills, marketplace } = await anwendungsfaelle.quelleHinzufuegen(quelle);
+            console.log(`Quelle ${quelleAlsText(quelle)} (${quelle.art}), ${skills.length} Skills:`);
+            for (const skill of skills)
+                console.log(`  ${skill.name}  ${skill.pfad}`);
+            if (marketplace !== null) {
+                console.log(`Marketplace ${marketplace.name}, ${marketplace.plugins.length} Plugins:`);
+                for (const plugin of marketplace.plugins) {
+                    const abh = plugin.dependencies.length === 0 ? '' : `  braucht ${plugin.dependencies.join(', ')}`;
+                    console.log(`  ${plugin.name}  ${plugin.skills.map((s) => s.pfad).join(', ')}${abh}`);
+                }
+            }
+            return 0;
+        }
+        if (unterkommando === 'list') {
+            const zustand = await ports.zustand.lesen();
+            if (zustand.quellen.length === 0)
+                console.log('Keine Quellen.');
+            for (const quelle of zustand.quellen)
+                console.log(`${quelle.art}  ${quelleAlsText(quelle)}`);
+            return 0;
+        }
+        throw new Error('source add <url|pfad> oder source list');
+    }
+    if (kommando === 'dir') {
+        const { rest, werte } = schalterLesen(argv.slice(1));
+        const unterkommando = rest[0];
+        if (unterkommando === 'add') {
+            const pfad = rest[1];
+            if (pfad === undefined)
+                throw new Error('dir add braucht einen Pfad');
+            const composer = werte.get('composer');
+            const ergebnis = composer === undefined
+                ? await anwendungsfaelle.arbeitsverzeichnisHinzufuegen(pfad)
+                : await anwendungsfaelle.arbeitsverzeichnisHinzufuegen(pfad, composer);
+            console.log(`Arbeitsverzeichnis ${ergebnis.pfad}`);
+            if (ergebnis.zeigerPfad !== undefined)
+                console.log(`  Zeiger ${ergebnis.zeigerPfad}`);
+            if (ergebnis.hinweis !== undefined)
+                console.log(`  ${ergebnis.hinweis}`);
+            return 0;
+        }
+        if (unterkommando === 'forget') {
+            const pfad = rest[1];
+            if (pfad === undefined)
+                throw new Error('dir forget braucht einen Pfad');
+            await anwendungsfaelle.arbeitsverzeichnisVergessen(pfad);
+            console.log(`Arbeitsverzeichnis ${path.resolve(pfad)} vergessen, die Links bleiben liegen.`);
+            return 0;
+        }
+        if (unterkommando === 'list') {
+            const zustand = await ports.zustand.lesen();
+            if (zustand.arbeitsverzeichnisse.length === 0)
+                console.log('Keine Arbeitsverzeichnisse.');
+            for (const pfad of zustand.arbeitsverzeichnisse) {
+                const bindung = zustand.bindungen.find((b) => b.ziel.ort.art === 'arbeitsverzeichnis' && b.ziel.ort.pfad === pfad);
+                console.log(`${pfad}  ${bindung === undefined ? 'ohne Zeiger' : bindung.zeigerPfad}`);
+            }
+            return 0;
+        }
+        throw new Error('dir add <pfad>, dir forget <pfad> oder dir list');
+    }
+    if (kommando === 'link' || kommando === 'unlink') {
+        const { rest, werte, flaggen } = schalterLesen(argv.slice(1));
+        const skill = rest[0];
+        if (skill === undefined)
+            throw new Error(`${kommando} braucht einen Skill-Namen`);
+        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') {
+            // Verzeichnis merken und binden, damit status es wiederfindet und der Zeiger bekannt ist (E21).
+            const composer = werte.get('composer');
+            if (composer === undefined)
+                await anwendungsfaelle.arbeitsverzeichnisHinzufuegen(ziel.ort.pfad);
+            else
+                await anwendungsfaelle.arbeitsverzeichnisHinzufuegen(ziel.ort.pfad, composer);
+        }
+        if (kommando === 'unlink') {
+            await anwendungsfaelle.linkEntfernen({ skill, ziel, lokal });
+            console.log(`Link ${skill} entfernt.`);
+            return 0;
+        }
+        const quelle = werte.get('quelle');
+        const version = werte.get('version');
+        const link = await anwendungsfaelle.linkLegen({
+            skill,
+            ziel,
+            ...(quelle === undefined ? {} : { quelle }),
+            ...(version === undefined ? {} : { version }),
+            ersetzen: flaggen.has('ersetzen'),
+            lokal,
+        });
+        const spanne = version === undefined ? '' : `${version} → `;
+        console.log(`${link.name} -> ${spanne}${quelleAlsText(link.checkout.quelle)} @ ${link.checkout.ref} (${link.skill.pfad})`);
+        if (link.hinweis !== undefined)
+            console.log(link.hinweis);
+        return 0;
+    }
+    if (kommando === 'adopt') {
+        const { rest, werte, flaggen } = schalterLesen(argv.slice(1));
+        const ziel = { harness: werte.get('harness') ?? 'claude-code', ort: ortLesen(werte.get('ort')) };
+        const probelauf = flaggen.has('probelauf');
+        const name = rest[0];
+        if (ziel.ort.art === 'arbeitsverzeichnis' && !probelauf) {
+            const composer = werte.get('composer');
+            if (composer === undefined)
+                await anwendungsfaelle.arbeitsverzeichnisHinzufuegen(ziel.ort.pfad);
+            else
+                await anwendungsfaelle.arbeitsverzeichnisHinzufuegen(ziel.ort.pfad, composer);
+        }
+        const ergebnis = await anwendungsfaelle.uebernehmen({
+            ziel,
+            ...(name === undefined ? {} : { name }),
+            probelauf,
+            lokal: flaggen.has('local') || flaggen.has('lokal'),
+        });
+        if (probelauf)
+            console.log('Probelauf, es wird nichts geschrieben.');
+        let uebernommen = 0;
+        let uebersprungen = 0;
+        let neueQuellen = 0;
+        for (const eintrag of ergebnis.eintraege) {
+            if (eintrag.ergebnis === 'uebersprungen') {
+                uebersprungen++;
+                console.log(`  übersprungen  ${eintrag.name}  ${UEBERNAHME_GRUND[eintrag.grund]}`);
+                continue;
+            }
+            uebernommen++;
+            if (eintrag.quelleNeu)
+                neueQuellen++;
+            const quelleNeu = eintrag.quelleNeu ? '  (neue Quelle)' : '';
+            console.log(`  übernommen    ${eintrag.name}  ${quelleAlsText(eintrag.quelle)} @ ${eintrag.ref} (${eintrag.skill.pfad})${quelleNeu}`);
+        }
+        const quellenText = neueQuellen === 1 ? '1 neue Quelle' : `${neueQuellen} neue Quellen`;
+        console.log(`${uebernommen} übernommen, ${uebersprungen} übersprungen, ${quellenText}.`);
+        return 0;
+    }
+    if (kommando === 'plugin') {
+        const { rest, werte, flaggen } = schalterLesen(argv.slice(1));
+        const unterkommando = rest[0];
+        if (unterkommando === 'list') {
+            const marketplaces = await anwendungsfaelle.marketplaces();
+            if (marketplaces.length === 0)
+                console.log('Keine Quelle mit Marketplace.');
+            for (const marketplace of marketplaces) {
+                console.log(`Marketplace ${marketplace.name}  (${quelleAlsText(marketplace.quelle)})`);
+                for (const plugin of marketplace.plugins) {
+                    console.log(`  ${plugin.name}`);
+                    for (const skill of plugin.skills)
+                        console.log(`    Skill  ${skill.name}  ${skill.pfad}`);
+                    for (const abhaengigkeit of plugin.dependencies)
+                        console.log(`    braucht  ${abhaengigkeit}`);
+                }
+            }
+            return 0;
+        }
+        if (unterkommando !== 'add' && unterkommando !== 'remove')
+            throw new Error('plugin add <name>, plugin remove <name> oder plugin list');
+        const name = rest[1];
+        if (name === undefined)
+            throw new Error(`plugin ${unterkommando} braucht einen Plugin-Namen`);
+        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') {
+            const composer = werte.get('composer');
+            if (composer === undefined)
+                await anwendungsfaelle.arbeitsverzeichnisHinzufuegen(ziel.ort.pfad);
+            else
+                await anwendungsfaelle.arbeitsverzeichnisHinzufuegen(ziel.ort.pfad, composer);
+        }
+        const quelle = werte.get('quelle');
+        const ergebnis = unterkommando === 'add'
+            ? await anwendungsfaelle.pluginLegen({ plugin: name, ziel, ...(quelle === undefined ? {} : { quelle }), lokal })
+            : await anwendungsfaelle.pluginEntfernen({ plugin: name, ziel, lokal });
+        const verb = unterkommando === 'add' ? 'gelegt' : 'entfernt';
+        console.log(`Plugin ${pluginSchluessel(ergebnis.plugin)} ${verb} (${ergebnis.art})`);
+        if (ergebnis.skills.length > 0)
+            console.log(`  Skills: ${ergebnis.skills.join(', ')}`);
+        if (ergebnis.imZeiger)
+            console.log('  im Zeiger vermerkt');
+        if (ergebnis.hinweis !== undefined)
+            console.log(`  ${ergebnis.hinweis}`);
+        return 0;
+    }
+    if (kommando === 'sync') {
+        const { rest } = schalterLesen(argv.slice(1));
+        const ergebnis = await anwendungsfaelle.abgleich(rest[0]);
+        if (ergebnis.zeigerPfad !== undefined)
+            console.log(`Zeiger ${ergebnis.zeigerPfad}`);
+        for (const zeile of ergebnis.gelegt)
+            console.log(`  gelegt      ${zeile}`);
+        for (const zeile of ergebnis.vorhanden)
+            console.log(`  vorhanden   ${zeile}`);
+        for (const zeile of ergebnis.abweichend)
+            console.log(`  abweichend  ${zeile}`);
+        for (const zeile of ergebnis.fehler)
+            console.log(`  Fehler      ${zeile}`);
+        for (const zeile of ergebnis.hinweise)
+            console.log(zeile);
+        return 0;
+    }
+    if (kommando === 'update') {
+        const { checkouts: liste, pluginHarnesses } = await anwendungsfaelle.aktualisieren();
+        if (liste.length === 0)
+            console.log('Keine Checkouts.');
+        for (const { checkout, aktualisierung } of liste) {
+            const kopf = `${quelleAlsText(checkout.quelle)} @ ${checkout.ref}`;
+            if (aktualisierung.ergebnis === 'aktualisiert')
+                console.log(`  aktualisiert    ${kopf}  ${aktualisierung.von.slice(0, 8)} -> ${aktualisierung.nach.slice(0, 8)}`);
+            else if (aktualisierung.ergebnis === 'unveraendert')
+                console.log(`  unverändert     ${kopf}`);
+            else
+                console.log(`  übersprungen    ${kopf}  lokale Änderung (E15)`);
+        }
+        for (const name of pluginHarnesses)
+            console.log(`  Plugins         ${name} aktualisiert (E14)`);
+        return 0;
+    }
+    if (kommando === 'status') {
+        for (const zielZustand of await anwendungsfaelle.istZustand()) {
+            console.log(`Ziel ${zielZustand.ziel.harness} ${beschreibeOrt(zielZustand.ziel.ort)} (${zielZustand.verzeichnis})`);
+            if (zielZustand.eintraege.length === 0)
+                console.log('  (leer)');
+            for (const eintrag of zielZustand.eintraege) {
+                if (eintrag.art === 'fremd')
+                    console.log(`  ${eintrag.name}  fremd`);
+                else if (eintrag.art === 'link-ohne-quelle')
+                    console.log(`  ${eintrag.name}  Link ohne bekannte Quelle (${eintrag.checkoutPfad})`);
+                else {
+                    // Steht im Zeiger eine Versionseinschränkung, kommt sie vor den aufgelösten Ref (E33).
+                    const einschraenkung = zielZustand.einschraenkungen.get(eintrag.link.name);
+                    const spanne = einschraenkung === undefined ? '' : `${einschraenkung} → `;
+                    console.log(`  ${eintrag.link.name}  ${spanne}${quelleAlsText(eintrag.link.checkout.quelle)} @ ${eintrag.link.checkout.ref} (${eintrag.link.skill.pfad})`);
+                }
+            }
+            if (zielZustand.plugins !== undefined)
+                console.log(`  Plugins: ${zielZustand.plugins.length === 0 ? 'keine' : zielZustand.plugins.join(', ')}`);
+        }
+        const fehlend = await anwendungsfaelle.nichtVorhandeneHarnesses();
+        if (fehlend.length > 0)
+            console.log(`Nicht vorhanden: ${fehlend.join(', ')}`);
+        return 0;
+    }
+    throw new Error(`Unbekanntes Kommando „${kommando}"`);
+}
+function beschreibeOrt(ort) {
+    if (ort.art === 'home')
+        return 'home';
+    if (ort.art === 'profil')
+        return `profil:${ort.name}`;
+    return `dir:${ort.pfad}`;
+}
+function istModellFehler(fehler) {
+    return (fehler instanceof NameBelegt ||
+        fehler instanceof SkillMehrdeutig ||
+        fehler instanceof SkillUnbekannt ||
+        fehler instanceof OrtNichtUnterstuetzt ||
+        fehler instanceof ZeigerMehrdeutig ||
+        fehler instanceof HarnessNichtVorhanden ||
+        fehler instanceof KeinPassenderRef ||
+        fehler instanceof EinschraenkungOhneZeiger ||
+        fehler instanceof PluginMehrdeutig ||
+        fehler instanceof PluginUnbekannt ||
+        fehler instanceof AbhaengigkeitFehlt);
+}
+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}`);
+        return 1;
+    }
+}
+/**
+ * Direkt gestartet oder importiert. Über den Realpath, weil `npm install -g` einen Symlink in
+ * `bin/` legt: argv[1] ist dann der Symlink, import.meta.url schon sein Ziel.
+ */
+function direktGestartet() {
+    const einstieg = process.argv[1];
+    if (einstieg === undefined)
+        return false;
+    try {
+        return import.meta.url === pathToFileURL(realpathSync(einstieg)).href;
+    }
+    catch {
+        return false;
+    }
+}
+if (direktGestartet()) {
+    process.exitCode = await main(process.argv.slice(2), umgebungLesen());
+}