hmgr 0.0.4 → 0.0.6

package/dist/kern/modell.js

@@ -63,6 +63,69 @@ export function quelleSchluessel(quelle) {
     const ort = urlOrt(quelle.url);
     return ort === undefined ? quelle.url : ortSchluessel(ort);
 }
+/**
+ * Letztes nicht leeres Segment eines Pfads oder einer URL, ohne abschließende Schrägstriche.
+ * Trenner sind `/` und `\` (E65/B7-Nachbar B8): unter Windows kommt der Pfad als `C:\work\quelle`
+ * herein und ergab sonst den Namen „\work\quelle". Ein POSIX-Ordnername mit Backslash wird dadurch
+ * zerteilt — akzeptiert, das hier ist reine Anzeige-Ableitung und geht in keinen Schlüssel ein.
+ */
+function letztesSegment(text) {
+    const bereinigt = text.replace(/[/\\]+$/, '');
+    const segmente = bereinigt.split(/[/\\]/).filter((s) => s.length > 0);
+    return segmente[segmente.length - 1] ?? bereinigt;
+}
+/**
+ * Abgeleiteter Anzeigename einer Quelle (E59), ohne Rücksicht auf einen gespeicherten Namen: bei
+ * einer Git-Quelle das letzte Pfadsegment der URL ohne `.git`-Suffix (über `urlOrt`, wie E36 den
+ * Repo-Namen schon für die Identität liest), bei einer lokalen Quelle ihr Ordnername.
+ */
+export function quelleNameAbleiten(quelle) {
+    if (quelle.art === 'lokal')
+        return letztesSegment(quelle.pfad);
+    const ort = urlOrt(quelle.url);
+    return ort !== undefined ? ort.repo : letztesSegment(quelle.url);
+}
+/**
+ * Anzeigename einer Quelle (E59): der gespeicherte Name, sonst der abgeleitete. Reine Anzeige,
+ * geht nicht in `quelleSchluessel` ein. CLI und GUI nutzen ausschließlich diesen Helfer.
+ */
+export function quelleName(quelle) {
+    if (quelle.name !== undefined && quelle.name.trim().length > 0)
+        return quelle.name;
+    return quelleNameAbleiten(quelle);
+}
+/**
+ * Ein Anzeigename, den noch keine der genannten Quellen trägt (E59): der Wunschname, sonst mit
+ * angehängter Zahl. Nur für Wege, die eine Quelle nebenbei anlegen (Übernahme, E31): dort gibt es
+ * niemanden, der eine Kollision auflösen könnte, und ein Abbruch ließe die Übernahme ohne Ausweg
+ * scheitern. Wo der Nutzer den Namen selbst nennt, bleibt eine Kollision ein Fehler.
+ */
+export function quelleNameFrei(wunsch, vorhandene) {
+    const belegt = new Set(vorhandene.map(quelleName));
+    if (!belegt.has(wunsch))
+        return wunsch;
+    for (let n = 2;; n += 1) {
+        const kandidat = `${wunsch}-${n}`;
+        if (!belegt.has(kandidat))
+            return kandidat;
+    }
+}
+/** Dieselbe Quelle mit gesetztem Anzeigenamen (E59). `undefined` lässt sie unverändert. */
+export function quelleMitNamen(quelle, name) {
+    if (name === undefined)
+        return quelle;
+    return quelle.art === 'git' ? { art: 'git', url: quelle.url, name } : { art: 'lokal', pfad: quelle.pfad, name };
+}
+/** Ein Anzeigename, den schon eine andere geführte Quelle trägt (E59): Namen sind eindeutig. */
+export class QuelleNameBelegt extends Error {
+    angefragterName;
+    andere;
+    constructor(angefragterName, andere) {
+        super(`Name „${angefragterName}" ist schon vergeben an ${quelleAlsText(andere)}. Einen anderen Namen wählen.`);
+        this.angefragterName = angefragterName;
+        this.andere = andere;
+    }
+}
 export class NameBelegt extends Error {
     ziel;
     skillName;
@@ -72,6 +135,25 @@ export class NameBelegt extends Error {
         this.skillName = skillName;
     }
 }
+/**
+ * Der Link am Ziel ließ sich im Dateisystem nicht anlegen (E66). Ohne diesen Fehler käme ein roher
+ * Node-Stack beim Nutzer an, der weder Pfad noch Ausweg nennt. Der Handlungshinweis steht mit in
+ * der Meldung statt in `naechsterSchritt` der CLI: er nennt kein hmgr-Kommando, sondern eine
+ * Einstellung des Betriebssystems, und die GUI zeigt nur die Meldung.
+ */
+export class LinkAnlegenFehlgeschlagen extends Error {
+    linkPfad;
+    zielPfad;
+    ursache;
+    hinweis;
+    constructor(linkPfad, zielPfad, ursache, hinweis) {
+        super(`Der Link „${linkPfad}" auf „${zielPfad}" ließ sich nicht anlegen: ${ursache}\n${hinweis}`);
+        this.linkPfad = linkPfad;
+        this.zielPfad = zielPfad;
+        this.ursache = ursache;
+        this.hinweis = hinweis;
+    }
+}
 export class SkillMehrdeutig extends Error {
     name;
     quellen;
@@ -88,6 +170,14 @@ export class SkillUnbekannt extends Error {
         this.name = name;
     }
 }
+/** Eine Quelle, die im Zustand nicht geführt wird (E54): Entfernen kennt nur bekannte Quellen. */
+export class QuelleUnbekannt extends Error {
+    quelle;
+    constructor(quelle) {
+        super(`Quelle „${quelleAlsText(quelle)}" ist nicht bekannt`);
+        this.quelle = quelle;
+    }
+}
 export class PluginMehrdeutig extends Error {
     name;
     quellen;
@@ -134,6 +224,36 @@ export class EinschraenkungOhneZeiger extends Error {
         this.einschraenkung = einschraenkung;
     }
 }
+/**
+ * Schreiben in einen composer.json-Zeiger ist gesperrt, bis das Composer-Thema (E41, B13) gesondert
+ * entschieden ist (E57): der Zeiger ist ein geteiltes Team-Artefakt, ein Schreiben ohne Rücksprache
+ * beträfe Kollegen. Lesen bleibt erlaubt, nur link, unlink und plugin add/remove ohne `--local`
+ * treffen diese Sperre.
+ */
+export class ZeigerSchreibenGesperrt extends Error {
+    ziel;
+    constructor(ziel) {
+        super(`Schreiben in den Zeiger von ${zielSchluessel(ziel)} ist gesperrt, bis das Composer-Thema entschieden ist – ` +
+            'der Zeiger ist ein geteiltes Team-Artefakt. Nutze --local.');
+        this.ziel = ziel;
+    }
+}
+/**
+ * `quelleAufraeumen` bricht ab, wenn ein Checkout der Quelle lokale Änderungen hat (E15, F31a):
+ * geprüft VOR der ersten Löschung, nichts wird gelöscht, kein stilles Teil-Überspringen. Der
+ * Aufrufer lässt bei diesem Fehler auch das Vergessen der Quelle unterbleiben, alles bleibt liegen.
+ */
+export class QuelleAufraeumenLokaleAenderungen extends Error {
+    checkouts;
+    constructor(checkouts) {
+        const kopf = checkouts.length === 1
+            ? 'Ein Checkout hat lokale Änderungen, nichts wurde gelöscht:'
+            : `${checkouts.length} Checkouts haben lokale Änderungen, nichts wurde gelöscht:`;
+        const pfade = checkouts.map((c) => `  ${c.pfad}`).join('\n');
+        super(`${kopf}\n${pfade}\nCommitte/pushe die Änderungen oder verwirf sie, danach lässt sich das Entfernen wiederholen.`);
+        this.checkouts = checkouts;
+    }
+}
 export class OrtNichtUnterstuetzt extends Error {
     harness;
     ort;
@@ -159,3 +279,180 @@ export class HarnessNichtVorhanden extends Error {
         this.harness = harness;
     }
 }
+/** Ein Name, den kein Harness-Typ trägt: Aktivieren, Deaktivieren und Säubern kennen nur bekannte Typen (E38). */
+export class HarnessTypUnbekannt extends Error {
+    harness;
+    constructor(harness) {
+        super(`„${harness}" ist kein bekannter Harness-Typ`);
+        this.harness = harness;
+    }
+}
+/**
+ * Ein genannter Name, unter dem am Ziel kein fremder Eintrag liegt (E46): weder Übernehmen mit
+ * Eintrag-Auswahl noch Löschen kennen einen anderen als einen tatsächlich fremden Eintrag. Ein
+ * hmgr-eigener Link zählt hier ebenso wenig wie ein Name, der gar nicht existiert.
+ */
+export class FremderEintragUnbekannt extends Error {
+    ziel;
+    name;
+    constructor(ziel, name) {
+        super(`Im Ziel ${zielSchluessel(ziel)} liegt kein fremder Eintrag „${name}"`);
+        this.ziel = ziel;
+        this.name = name;
+    }
+}
+/** Ein Harness-Typ ohne die Fähigkeit „verwalteter Skill-Ordner" (E56): heute nur hermes. */
+export class SkillOrdnerFaehigkeitFehlt extends Error {
+    harness;
+    constructor(harness) {
+        super(`Harness ${harness} kennt keinen verwalteten Skill-Ordner`);
+        this.harness = harness;
+    }
+}
+/** Für ein Ziel ist schon ein Skill-Ordner verwaltet (E56): Festlegen erlaubt nur genau einen. */
+export class SkillOrdnerBereitsVerwaltet extends Error {
+    ziel;
+    pfad;
+    constructor(ziel, pfad) {
+        super(`Für ${zielSchluessel(ziel)} ist schon ein Skill-Ordner verwaltet: ${pfad}`);
+        this.ziel = ziel;
+        this.pfad = pfad;
+    }
+}
+/** Für ein Ziel ist kein Skill-Ordner verwaltet (E56): Entfernen kennt nur einen vorhandenen Eintrag. */
+export class SkillOrdnerNichtVerwaltet extends Error {
+    ziel;
+    constructor(ziel) {
+        super(`Für ${zielSchluessel(ziel)} ist kein Skill-Ordner verwaltet`);
+        this.ziel = ziel;
+    }
+}
+/**
+ * Ein Pfad, der als verwalteter Skill-Ordner nicht in Frage kommt (E56): außerhalb des
+ * Hermes-Home oder Hermes' eigener Ordner `skills` (oder darunter).
+ */
+export class SkillOrdnerUngueltig extends Error {
+    pfad;
+    grund;
+    constructor(pfad, grund) {
+        super(grund === 'ausserhalb'
+            ? `${pfad} liegt nicht unterhalb des Hermes-Home`
+            : `${pfad} ist Hermes' eigener Skill-Ordner`);
+        this.pfad = pfad;
+        this.grund = grund;
+    }
+}
+/** Ein Name, der im MCP-Katalog nicht steht (E61): mcp add und mcp remove kennen nur Katalog-Einträge. */
+export class McpUnbekannt extends Error {
+    mcpName;
+    constructor(mcpName) {
+        super(`MCP „${mcpName}" steht nicht im Katalog`);
+        this.mcpName = mcpName;
+    }
+}
+/** Ein Harness-Typ ohne die Fähigkeit MCP-Server (E61): heute nur claude-code und hermes. */
+export class McpFaehigkeitFehlt extends Error {
+    harness;
+    constructor(harness) {
+        super(`Harness ${harness} kennt keine MCP-Server`);
+        this.harness = harness;
+    }
+}
+/**
+ * Ein Ort, an dem dieser Harness-Typ keine MCP-Server verwaltet (E61): die Fähigkeit hängt am
+ * Adapter, nicht am Harness-Namen (E16), aber Hermes kennt grundsätzlich keine Projektebene für
+ * MCPs, das bekommt eine eigene Erklärung.
+ */
+export class McpEbeneNichtUnterstuetzt extends Error {
+    harness;
+    ort;
+    constructor(harness, ort) {
+        const erklaerung = harness === 'hermes' && ort === 'arbeitsverzeichnis' ? ' – Hermes kennt keine Projektebene für MCPs' : '';
+        super(`${harness} kennt für MCP-Server den Ort „${ort}" nicht${erklaerung}`);
+        this.harness = harness;
+        this.ort = ort;
+    }
+}
+/**
+ * Am Ziel liegt unter diesem Namen schon ein MCP-Server, den hmgr nicht selbst gelegt hat oder der
+ * vom Katalogblock abweicht (E61). hmgr überschreibt so etwas nicht stillschweigend.
+ */
+export class McpAbweichenderEintrag extends Error {
+    ziel;
+    mcpName;
+    constructor(ziel, mcpName) {
+        super(`In ${zielSchluessel(ziel)} liegt schon ein MCP-Server „${mcpName}", der nicht von hmgr stammt oder vom ` +
+            'Katalogblock abweicht. hmgr überschreibt ihn nicht stillschweigend.');
+        this.ziel = ziel;
+        this.mcpName = mcpName;
+    }
+}
+/**
+ * `aushaengen` trifft einen Namen, der nicht im schreibbaren Bereich liegt, aber in einem geteilten
+ * Fundort steht (E61-Nachtrag), etwa der `.mcp.json` einer Projektwurzel bei Claude Code. Anders als
+ * der reguläre idempotente Fall (nirgends eingehängt) bleibt hier tatsächlich ein Eintrag liegen:
+ * die Meldung darf das nicht als Erfolg verkaufen. Seit E64 gibt es dafür einen Weg in hmgr selbst,
+ * die Meldung nennt ihn statt „von Hand ändern".
+ */
+export class McpNurGeteilterFundort extends Error {
+    ziel;
+    mcpName;
+    datei;
+    constructor(ziel, mcpName, datei) {
+        super(`„${mcpName}" steht in der geteilten ${datei}, nicht in deiner privaten Konfiguration. `
+            + `hmgr mcp migrate ${mcpName} übernimmt ihn in den privaten Scope und entfernt ihn aus der Datei.`);
+        this.ziel = ziel;
+        this.mcpName = mcpName;
+        this.datei = datei;
+    }
+}
+/**
+ * Übernehmen (E64) an einem Ort, der keine geteilte Konfigurationsdatei kennt: ein Harness ohne
+ * diese Fähigkeit (Hermes kennt keine geteilte Datei) oder eine Ebene ohne sie (bei Claude Code hat
+ * nur ein Arbeitsverzeichnis eine `.mcp.json`, das Home nicht).
+ */
+export class McpUebernahmeNichtMoeglich extends Error {
+    ziel;
+    constructor(ziel) {
+        super(`In ${zielSchluessel(ziel)} gibt es keine geteilte Konfigurationsdatei, aus der hmgr einen MCP-Server übernehmen könnte.`);
+        this.ziel = ziel;
+    }
+}
+/** Übernehmen (E64) eines Namens, der in der geteilten Datei gar nicht steht. */
+export class McpNichtInGeteilterDatei extends Error {
+    ziel;
+    mcpName;
+    datei;
+    constructor(ziel, mcpName, datei) {
+        super(`„${mcpName}" steht nicht in ${datei}, da ist nichts zu übernehmen.`);
+        this.ziel = ziel;
+        this.mcpName = mcpName;
+        this.datei = datei;
+    }
+}
+/**
+ * Teilerfolg beim Übernehmen (E64): der Eintrag steht schon im privaten Scope, ließ sich aber nicht
+ * aus der geteilten Datei entfernen. Die Reihenfolge ist bewusst so gewählt (erst eintragen, dann
+ * entfernen), damit in diesem Fall nichts verloren ist. Die Meldung sagt, was der Nutzer jetzt
+ * vorfindet, statt nur den Fehlschlag zu nennen.
+ */
+export class McpUebernahmeUnvollstaendig extends Error {
+    ziel;
+    mcpName;
+    datei;
+    constructor(ziel, mcpName, datei, grund) {
+        super(`„${mcpName}" steht jetzt in deiner privaten Konfiguration, ließ sich aber nicht aus ${datei} entfernen: ${grund}. `
+            + 'Der Eintrag steht damit doppelt; wirksam ist der private. Entferne ihn aus der Datei von Hand, dann ist die Übernahme fertig.');
+        this.ziel = ziel;
+        this.mcpName = mcpName;
+        this.datei = datei;
+    }
+}
+/** Der MCP-Katalog ~/.hmgr/mcp.yaml lässt sich nicht lesen (E61): kaputtes YAML oder falsches Format. */
+export class McpKatalogFehler extends Error {
+    pfad;
+    constructor(pfad, grund) {
+        super(`MCP-Katalog ${pfad}: ${grund}`);
+        this.pfad = pfad;
+    }
+}

package/dist/kern/quelle-ort.js

@@ -12,9 +12,20 @@ export function ortAusSegmenten(host, segmente) {
     const besitzer = gefiltert[gefiltert.length - 2] ?? '_';
     return { host: host.toLowerCase(), besitzer, repo };
 }
+/**
+ * Ein Windows-Laufwerkspfad (E65/B12): ein einzelner ASCII-Buchstabe, ein Doppelpunkt und dann ein
+ * Trenner — `C:\work\quelle` oder `C:/work/quelle`. Genau diese Form sieht sonst aus wie eine
+ * scp-Kurzform `host:pfad` und wurde als Host „C" mit dem Pfad „\work\quelle" gelesen. Ein Hostname
+ * aus einem einzelnen Buchstaben ist theoretisch erlaubt, kommt als Git-Remote aber nicht vor; der
+ * Windows-Pfad kommt vor.
+ */
+export function istWindowsLaufwerkspfad(text) {
+    return /^[A-Za-z]:[\\/]/.test(text.trim());
+}
 /**
  * Zerlegt eine Git-URL: `git@host:besitzer/repo.git`, `ssh://git@host/besitzer/repo`,
- * `https://host/besitzer/repo.git`, `file:///pfad`. Ein Text, der keine URL ist, gibt undefined.
+ * `https://host/besitzer/repo.git`, `file:///pfad`. Ein Text, der keine URL ist, gibt undefined —
+ * darunter jeder nackte Pfad, der lokale POSIX-Pfad ebenso wie der Windows-Laufwerkspfad (E65/B12).
  */
 export function urlOrt(url) {
     const text = url.trim().replace(/\/+$/, '');
@@ -32,6 +43,8 @@ export function urlOrt(url) {
             return ortAusSegmenten('local', segmente);
         return ortAusSegmenten(zerlegt.hostname, segmente);
     }
+    if (istWindowsLaufwerkspfad(text))
+        return undefined;
     const scp = /^(?:[^@/]+@)?([^@/:]+):(.+)$/.exec(text);
     if (scp)
         return ortAusSegmenten(scp[1], scp[2].split('/'));

package/dist/ports/harness.js

@@ -4,3 +4,19 @@ export function kannProfile(h) {
 export function kannPlugins(h) {
     return h.plugins !== undefined;
 }
+export function kannMcp(h) {
+    return h.mcp !== undefined;
+}
+export function kannZurueckbauen(h) {
+    return typeof h.zurueckbauen === 'function';
+}
+export function kannIstRegistriert(h) {
+    return typeof h.istRegistriert === 'function';
+}
+export function kannSkillOrdner(h) {
+    return (typeof h.verwalteterSkillOrdner === 'function' &&
+        typeof h.skillOrdnerOrte === 'function' &&
+        typeof h.skillOrdnerFestlegen === 'function' &&
+        typeof h.skillOrdnerEntfernen === 'function' &&
+        typeof h.skillOrdnerLoeschen === 'function');
+}

package/dist/ports/mcp-katalog.js

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

package/dist/ports/umgebung.js

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

package/dist/ports/zustand.js

@@ -1,3 +1,3 @@
 export function leererZustand() {
-    return { quellen: [], arbeitsverzeichnisse: [], bindungen: [] };
+    return { quellen: [], arbeitsverzeichnisse: [], bindungen: [], aktiveHarnesses: ['claude-code'], ignorierteEintraege: [] };
 }

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "hmgr",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "Harness Manager: Skills und Plugins für AI-Harnesses verwalten",
   "license": "MIT",
   "author": "Tim Kaufmann",
   "type": "module",
+  "main": "dist/gui/main.js",
   "bin": {
     "hmgr": "dist/cli/main.js"
   },
@@ -18,22 +19,66 @@
   },
   "scripts": {
     "dev": "node src/cli/main.ts",
-    "build": "tsc -p tsconfig.build.json",
+    "build": "tsc -p tsconfig.build.json && node scripts/copy-gui-assets.mjs",
+    "gui": "npm run build && electron dist/gui/main.js",
+    "gui:smoke": "npm run build && node scripts/gui-smoke-test.ts",
+    "gui:app": "npm run build && electron-builder --mac --arm64",
+    "gui:app:win": "npm run build && electron-builder --win --x64",
+    "gui:install": "npm run build && electron-builder --mac dir --arm64 && ditto release/mac-arm64/hmgr.app /Applications/hmgr.app",
     "test": "vitest run",
     "test:watch": "vitest",
     "type-check": "tsc --noEmit",
     "prepack": "npm run build"
   },
   "dependencies": {
+    "cross-spawn": "^7.0.6",
     "yaml": "^2.8.0"
   },
   "devDependencies": {
+    "@types/cross-spawn": "^6.0.6",
     "@types/node": "^24.0.0",
+    "electron": "^44.0.0",
+    "electron-builder": "^26.15.3",
     "typescript": "^5.9.0",
     "vitest": "^3.2.0"
   },
   "repository": {
     "type": "git",
     "url": "git+https://gitea.timkaufmann.de/tim/hmgr.git"
+  },
+  "build": {
+    "appId": "de.timkaufmann.hmgr",
+    "productName": "hmgr",
+    "directories": {
+      "output": "release",
+      "buildResources": "build"
+    },
+    "files": [
+      "dist/**/*",
+      "package.json"
+    ],
+    "asar": true,
+    "mac": {
+      "category": "public.app-category.developer-tools",
+      "icon": "build/icon.icns",
+      "target": [
+        { "target": "dir", "arch": ["arm64"] },
+        { "target": "zip", "arch": ["arm64"] }
+      ],
+      "identity": null
+    },
+    "win": {
+      "icon": "build/icon.ico",
+      "target": [
+        { "target": "nsis", "arch": ["x64"] }
+      ]
+    },
+    "nsis": {
+      "oneClick": false,
+      "perMachine": false,
+      "allowElevation": false,
+      "allowToChangeInstallationDirectory": true,
+      "artifactName": "${productName}-Setup-${version}-${arch}.${ext}"
+    }
   }
 }