hmgr 0.0.5 → 0.0.7

package/dist/kern/modell.js

@@ -1,5 +1,12 @@
 // Begriffe aus CONTEXT.md. Nur Werte und Regeln, keine Pfade zu Dateien außerhalb des Modells.
 import { ortSchluessel, urlOrt } from "./quelle-ort.js";
+/**
+ * Identität eines Bundles (E69): Quelle der Definition plus Name. Zwei Quellen dürfen denselben
+ * Bundle-Namen führen, mehrdeutig wird es erst beim Suchen, wie bei Skills (E12).
+ */
+export function bundleSchluessel(bundle) {
+    return `${quelleSchluessel(bundle.quelle)}#${bundle.name}`;
+}
 /** Ansprache eines Plugins im Zeiger und gegenüber der claude-CLI: `<plugin>@<marketplace>`. */
 export function pluginSchluessel(plugin) {
     return `${plugin.name}@${plugin.marketplace}`;
@@ -63,10 +70,15 @@ 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. */
+/**
+ * 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);
+    const bereinigt = text.replace(/[/\\]+$/, '');
+    const segmente = bereinigt.split(/[/\\]/).filter((s) => s.length > 0);
     return segmente[segmente.length - 1] ?? bereinigt;
 }
 /**
@@ -130,6 +142,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;
@@ -318,3 +349,190 @@ export class SkillOrdnerUngueltig extends Error {
         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;
+    }
+}
+/** Ein Bundle-Name, den keine bekannte Quelle führt (E69). */
+export class BundleUnbekannt extends Error {
+    bundleName;
+    constructor(bundleName) {
+        super(`Bundle „${bundleName}" steht in keiner Quelle`);
+        this.bundleName = bundleName;
+    }
+}
+/** Denselben Bundle-Namen führen mehrere Quellen (E69, Regel wie E12 bei Skills). */
+export class BundleMehrdeutig extends Error {
+    bundleName;
+    quellen;
+    constructor(bundleName, quellen) {
+        super(`Bundle „${bundleName}" liegt in mehreren Quellen: ${quellen.map(quelleSchluessel).join(', ')}`);
+        this.bundleName = bundleName;
+        this.quellen = quellen;
+    }
+}
+/**
+ * Die Definition nennt Mitglieder, die sich auf dieser Maschine nicht auflösen lassen (E69, F66b):
+ * eine Quelle ohne Zugriff oder ein Pfad, der in ihr kein Skill ist. Ein halbes Bundle wäre stilles
+ * Fehlen von Skills, die falsche Fehlersorte (B13) — deshalb wird abgebrochen, bevor irgendetwas
+ * verlinkt ist, und bevor eine fehlende Quelle in den Zustand kommt.
+ */
+export class BundleMitgliederFehlen extends Error {
+    bundleName;
+    fehler;
+    constructor(bundleName, fehler) {
+        const zeilen = fehler.map((f) => `  ${f.adresse} (${f.pfad}): ${f.grund}`).join('\n');
+        super(`Bundle „${bundleName}" ist auf dieser Maschine nicht vollständig herstellbar, nichts wurde verlinkt:\n${zeilen}`);
+        this.bundleName = bundleName;
+        this.fehler = fehler;
+    }
+}
+/**
+ * Am Ziel liegt unter dem Namen eines Mitglieds schon etwas anderes (E69, F67): ein anderer Skill
+ * gleichen Namens, ein fremder Eintrag oder ein Link, der zu einem anderen Bundle gehört. Derselbe
+ * Skill aus derselben Quelle ist kein Konflikt, er wird als Mitglied übernommen. Abbruch wie bei
+ * `BundleMitgliederFehlen`, die Meldung listet alle Konflikte.
+ */
+export class BundleNamenskonflikte extends Error {
+    bundleName;
+    ziel;
+    konflikte;
+    constructor(bundleName, ziel, konflikte) {
+        const zeilen = konflikte.map((k) => `  ${k.name}: ${k.grund}`).join('\n');
+        super(`Bundle „${bundleName}" lässt sich in ${zielSchluessel(ziel)} nicht anlegen, nichts wurde verlinkt:\n${zeilen}`);
+        this.bundleName = bundleName;
+        this.ziel = ziel;
+        this.konflikte = konflikte;
+    }
+}
+/** Ein Bundle, das in diesem Ziel nicht installiert ist (E69): Entfernen kennt nur installierte. */
+export class BundleNichtInstalliert extends Error {
+    bundleName;
+    ziel;
+    constructor(bundleName, ziel) {
+        super(`In ${zielSchluessel(ziel)} ist kein Bundle „${bundleName}" installiert`);
+        this.bundleName = bundleName;
+        this.ziel = ziel;
+    }
+}
+/**
+ * Eine Bundle-Definition lässt sich nicht lesen (E69): kaputtes YAML oder ein Feld außerhalb des
+ * dokumentierten Formats. Wie beim MCP-Katalog (E61) mit Datei, Feld und Grund in der Meldung.
+ */
+export class BundleDateiFehler extends Error {
+    datei;
+    constructor(datei, grund) {
+        super(`Bundle-Datei ${datei}: ${grund}`);
+        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,6 +4,9 @@ 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';
 }

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,17 @@
+/**
+ * Fassung des Dateiformats. 1 ist alles vor E69 (das Feld fehlt dort und wird beim Lesen ergänzt),
+ * 2 kennt `bundleInstallationen`. Bestand ohne Bundles läuft unverändert weiter: ein fehlendes Feld
+ * ist eine leere Liste, geschrieben wird danach in der aktuellen Fassung.
+ */
+export const ZUSTAND_FASSUNG = 2;
 export function leererZustand() {
-    return { quellen: [], arbeitsverzeichnisse: [], bindungen: [], aktiveHarnesses: ['claude-code'], ignorierteEintraege: [] };
+    return {
+        fassung: ZUSTAND_FASSUNG,
+        quellen: [],
+        arbeitsverzeichnisse: [],
+        bindungen: [],
+        aktiveHarnesses: ['claude-code'],
+        ignorierteEintraege: [],
+        bundleInstallationen: [],
+    };
 }

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "hmgr",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "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"
   },
@@ -21,22 +22,78 @@
     "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"
+    "url": "git+https://gitea.timkaufmann.de/taquiri/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}"
+    }
   }
 }