hmgr 0.0.1

package/dist/kern/modell.js

@@ -0,0 +1,146 @@
+// Begriffe aus CONTEXT.md. Nur Werte und Regeln, keine Pfade zu Dateien außerhalb des Modells.
+/** Ansprache eines Plugins im Zeiger und gegenüber der claude-CLI: `<plugin>@<marketplace>`. */
+export function pluginSchluessel(plugin) {
+    return `${plugin.name}@${plugin.marketplace}`;
+}
+export function pluginSchluesselZerlegen(text) {
+    const trenner = text.lastIndexOf('@');
+    if (trenner <= 0)
+        return { name: text };
+    return { name: text.slice(0, trenner), marketplace: text.slice(trenner + 1) };
+}
+/**
+ * URL, unter der Claude Code den Marketplace einer Quelle registriert (E24). Git-Hosts außer
+ * GitHub und GitLab brauchen das `.git`-Suffix, sonst liest Claude Code die URL als Direktlink
+ * auf eine marketplace.json.
+ */
+export function marketplaceUrl(quelle) {
+    if (quelle.art === 'lokal')
+        return quelle.pfad;
+    const url = quelle.url.replace(/\/+$/, '');
+    if (url.endsWith('.git'))
+        return url;
+    let host;
+    if (url.includes('://')) {
+        try {
+            host = new URL(url).hostname;
+        }
+        catch {
+            return url;
+        }
+    }
+    else {
+        // SSH in scp-Schreibweise: git@host:besitzer/repo
+        host = /^(?:[^@/]+@)?([^@/:]+):/.exec(url)?.[1] ?? '';
+    }
+    if (host.length === 0)
+        return url;
+    const klein = host.toLowerCase();
+    if (klein === 'github.com' || klein === 'gitlab.com')
+        return url;
+    return `${url}.git`;
+}
+export function zielSchluessel(ziel) {
+    const o = ziel.ort;
+    const ort = o.art === 'home' ? 'home' : o.art === 'profil' ? `profil:${o.name}` : `dir:${o.pfad}`;
+    return `${ziel.harness}/${ort}`;
+}
+export function quelleSchluessel(quelle) {
+    return quelle.art === 'git' ? quelle.url : `lokal:${quelle.pfad}`;
+}
+export class NameBelegt extends Error {
+    ziel;
+    skillName;
+    constructor(ziel, skillName) {
+        super(`Im Ziel ${zielSchluessel(ziel)} liegt bereits ein fremder Eintrag „${skillName}"`);
+        this.ziel = ziel;
+        this.skillName = skillName;
+    }
+}
+export class SkillMehrdeutig extends Error {
+    name;
+    quellen;
+    constructor(name, quellen) {
+        super(`Skill „${name}" liegt in mehreren Quellen: ${quellen.map(quelleSchluessel).join(', ')}`);
+        this.name = name;
+        this.quellen = quellen;
+    }
+}
+export class SkillUnbekannt extends Error {
+    name;
+    constructor(name) {
+        super(`Skill „${name}" liegt in keiner Quelle`);
+        this.name = name;
+    }
+}
+export class PluginMehrdeutig extends Error {
+    name;
+    quellen;
+    constructor(name, quellen) {
+        super(`Plugin „${name}" liegt in mehreren Marketplaces: ${quellen.map(quelleSchluessel).join(', ')}`);
+        this.name = name;
+        this.quellen = quellen;
+    }
+}
+export class PluginUnbekannt extends Error {
+    name;
+    constructor(name) {
+        super(`Plugin „${name}" liegt in keinem Marketplace der bekannten Quellen`);
+        this.name = name;
+    }
+}
+/** Eine Abhängigkeit löst sich nur im selben Marketplace auf (Q7, kein Cross-Marketplace). */
+export class AbhaengigkeitFehlt extends Error {
+    plugin;
+    abhaengigkeit;
+    constructor(plugin, abhaengigkeit) {
+        super(`Plugin „${plugin}" braucht „${abhaengigkeit}", das im selben Marketplace nicht steht`);
+        this.plugin = plugin;
+        this.abhaengigkeit = abhaengigkeit;
+    }
+}
+export class KeinPassenderRef extends Error {
+    skill;
+    einschraenkung;
+    constructor(skill, einschraenkung) {
+        super(`Kein Ref für „${skill}" passt zu ${einschraenkung}`);
+        this.skill = skill;
+        this.einschraenkung = einschraenkung;
+    }
+}
+/** Eine Versionseinschränkung braucht einen Zeiger, in dem sie stehen kann (E33). */
+export class EinschraenkungOhneZeiger extends Error {
+    ziel;
+    einschraenkung;
+    constructor(ziel, einschraenkung) {
+        super(`Für ${zielSchluessel(ziel)} gibt es keinen Zeiger, in den „${einschraenkung}" gehört. ` +
+            'Eine Versionseinschränkung gibt es nur für ein Arbeitsverzeichnis mit composer.json, ohne --local.');
+        this.ziel = ziel;
+        this.einschraenkung = einschraenkung;
+    }
+}
+export class OrtNichtUnterstuetzt extends Error {
+    harness;
+    ort;
+    constructor(harness, ort) {
+        super(`Harness ${harness} kennt den Ort „${ort}" nicht`);
+        this.harness = harness;
+        this.ort = ort;
+    }
+}
+export class ZeigerMehrdeutig extends Error {
+    verzeichnis;
+    kandidaten;
+    constructor(verzeichnis, kandidaten) {
+        super(`Mehrere composer.json unter ${verzeichnis}: ${kandidaten.join(', ')}. Bitte eine mit --composer nennen`);
+        this.verzeichnis = verzeichnis;
+        this.kandidaten = kandidaten;
+    }
+}
+export class HarnessNichtVorhanden extends Error {
+    harness;
+    constructor(harness) {
+        super(`Harness ${harness} liegt nicht auf diesem Rechner`);
+        this.harness = harness;
+    }
+}

package/dist/kern/version.js

@@ -0,0 +1,244 @@
+// Versionen und Einschränkungen nach Composer-Regeln (E33). Reines Modul: keine Ports, kein Git.
+/**
+ * Eine Version mit optionalem Präfix `v`, ein bis drei Stellen, dazu eine Vorabversion, die mit
+ * einem Buchstaben beginnt. So bleibt `1.2.3.4` unlesbar und wird nicht als Vorabversion von
+ * `1.2.3` gedeutet.
+ */
+const MUSTER = /^[vV]?(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:[-_.]?([A-Za-z][0-9A-Za-z.\-_]*))?$/;
+/** `1.0 - 2.0`: Composer verlangt Leerraum um den Bindestrich. */
+const SPANNE = /^(\S+)\s+-\s+(\S+)$/;
+const VERGLEICH = /^(>=|<=|!=|<>|==|>|<|=)\s*(.+)$/;
+/** `2.1.*` und `2.*`, mit optionalem Präfix `v`. */
+const WILDCARD = /^[vV]?(\d+)(?:\.(\d+))?\.\*$/;
+function fassung(haupt, neben, patch) {
+    return { haupt, neben, patch, vorab: [] };
+}
+function kennungen(text) {
+    const teile = [];
+    for (const stueck of text.split(/[.\-_]/)) {
+        for (const treffer of stueck.match(/\d+|\D+/g) ?? [])
+            teile.push(/^\d+$/.test(treffer) ? Number(treffer) : treffer.toLowerCase());
+    }
+    return teile;
+}
+/** Version samt der Zahl genannter Stellen. Tilde, Caret und Wildcard brauchen diese Zahl. */
+function stellen(text) {
+    const treffer = MUSTER.exec(text.trim());
+    if (treffer === null)
+        return null;
+    const roh = treffer[4];
+    return {
+        version: {
+            haupt: Number(treffer[1] ?? 0),
+            neben: Number(treffer[2] ?? 0),
+            patch: Number(treffer[3] ?? 0),
+            vorab: roh === undefined ? [] : kennungen(roh),
+        },
+        anzahl: treffer[3] !== undefined ? 3 : treffer[2] !== undefined ? 2 : 1,
+    };
+}
+/** Fehlende Stellen gelten als 0. Null heißt: der Text ist keine Version. */
+export function versionLesen(text) {
+    return stellen(text)?.version ?? null;
+}
+/** Kleiner, gleich, größer als -1, 0, 1. Eine Endfassung steht über ihren Vorabversionen. */
+export function vergleichen(a, b) {
+    if (a.haupt !== b.haupt)
+        return a.haupt < b.haupt ? -1 : 1;
+    if (a.neben !== b.neben)
+        return a.neben < b.neben ? -1 : 1;
+    if (a.patch !== b.patch)
+        return a.patch < b.patch ? -1 : 1;
+    if (a.vorab.length === 0 && b.vorab.length === 0)
+        return 0;
+    if (a.vorab.length === 0)
+        return 1;
+    if (b.vorab.length === 0)
+        return -1;
+    const laenge = Math.max(a.vorab.length, b.vorab.length);
+    for (let i = 0; i < laenge; i++) {
+        const x = a.vorab[i];
+        const y = b.vorab[i];
+        if (x === undefined)
+            return -1;
+        if (y === undefined)
+            return 1;
+        if (typeof x === 'number' && typeof y === 'number') {
+            if (x !== y)
+                return x < y ? -1 : 1;
+            continue;
+        }
+        // Eine Zahl steht unter einem Text, wie in `1.0.0-1` gegen `1.0.0-alpha`.
+        if (typeof x === 'number')
+            return -1;
+        if (typeof y === 'number')
+            return 1;
+        if (x !== y)
+            return x < y ? -1 : 1;
+    }
+    return 0;
+}
+/**
+ * Tilde: „`~1.2` ist gleichbedeutend mit `>=1.2 <2.0.0`, `~1.2.3` mit `>=1.2.3 <1.3.0`", die
+ * am weitesten rechts genannte Stelle darf wachsen (getcomposer.org, Writing Version Constraints).
+ * Bei nur einer Stelle wächst die Hauptversion.
+ */
+function tilde(gelesen) {
+    const { version, anzahl } = gelesen;
+    const obere = anzahl >= 3 ? fassung(version.haupt, version.neben + 1, 0) : fassung(version.haupt + 1, 0, 0);
+    return [
+        { operator: '>=', version },
+        { operator: '<', version: obere },
+    ];
+}
+/**
+ * Caret: „`^1.2.3` ist gleichbedeutend mit `>=1.2.3 <2.0.0`", vor 1.0 gilt „`^0.3` als
+ * `>=0.3.0 <0.4.0`" (getcomposer.org, Writing Version Constraints). Bei Hauptversion 0 wächst
+ * also die Nebenversion, sonst die Hauptversion.
+ */
+function caret(gelesen) {
+    const { version, anzahl } = gelesen;
+    const obere = version.haupt === 0 && anzahl >= 2 ? fassung(0, version.neben + 1, 0) : fassung(version.haupt + 1, 0, 0);
+    return [
+        { operator: '>=', version },
+        { operator: '<', version: obere },
+    ];
+}
+/** Eine Angabe ohne Operator: Tilde, Caret, Wildcard oder eine genaue Version. */
+function angabeLesen(text) {
+    if (text === '*')
+        return [];
+    if (text.startsWith('~') || text.startsWith('^')) {
+        const gelesen = stellen(text.slice(1));
+        if (gelesen === null)
+            return null;
+        return text.startsWith('~') ? tilde(gelesen) : caret(gelesen);
+    }
+    const wildcard = WILDCARD.exec(text);
+    if (wildcard !== null) {
+        const haupt = Number(wildcard[1] ?? 0);
+        const neben = wildcard[2];
+        // `1.0.*` heißt `>=1.0 <1.1`, `2.*` heißt `>=2.0 <3.0`.
+        return [
+            { operator: '>=', version: fassung(haupt, neben === undefined ? 0 : Number(neben), 0) },
+            {
+                operator: '<',
+                version: neben === undefined ? fassung(haupt + 1, 0, 0) : fassung(haupt, Number(neben) + 1, 0),
+            },
+        ];
+    }
+    const version = versionLesen(text);
+    if (version === null)
+        return null;
+    return [{ operator: '=', version }];
+}
+function tokenLesen(text) {
+    const vergleich = VERGLEICH.exec(text);
+    if (vergleich === null)
+        return angabeLesen(text);
+    const version = versionLesen(vergleich[2] ?? '');
+    if (version === null)
+        return null;
+    const roh = vergleich[1] ?? '=';
+    const operator = roh === '<>' ? '!=' : roh === '==' ? '=' : roh;
+    return [{ operator, version }];
+}
+/**
+ * Eine Bindestrich-Spanne: „`1.0 - 2.0` ist gleichbedeutend mit `>=1.0.0 <2.1`, weil aus der
+ * `2.0` eine `2.0.*` wird. `1.0.0 - 2.1.0` dagegen ist `>=1.0.0 <=2.1.0`" (getcomposer.org).
+ */
+function spanneLesen(von, bis) {
+    const unten = stellen(von);
+    const oben = stellen(bis);
+    if (unten === null || oben === null)
+        return null;
+    if (oben.anzahl >= 3)
+        return [
+            { operator: '>=', version: unten.version },
+            { operator: '<=', version: oben.version },
+        ];
+    const grenze = oben.anzahl === 2 ? fassung(oben.version.haupt, oben.version.neben + 1, 0) : fassung(oben.version.haupt + 1, 0, 0);
+    return [
+        { operator: '>=', version: unten.version },
+        { operator: '<', version: grenze },
+    ];
+}
+/** UND-verknüpfte Bedingungen, getrennt durch Leerzeichen oder Komma. */
+function gruppeLesen(text) {
+    if (text.length === 0)
+        return null;
+    const spanne = SPANNE.exec(text);
+    if (spanne !== null)
+        return spanneLesen(spanne[1] ?? '', spanne[2] ?? '');
+    const bedingungen = [];
+    for (const token of text.split(/[\s,]+/)) {
+        if (token.length === 0)
+            continue;
+        const gelesen = tokenLesen(token);
+        if (gelesen === null)
+            return null;
+        bedingungen.push(...gelesen);
+    }
+    return bedingungen;
+}
+/** Null heißt: der Text ist keine Einschränkung, er gilt dann als Ref-Name (E33). */
+export function einschraenkungLesen(text) {
+    const roh = text.trim();
+    if (roh.length === 0)
+        return null;
+    const gruppen = [];
+    for (const teil of roh.split('||')) {
+        const gruppe = gruppeLesen(teil.trim());
+        if (gruppe === null)
+            return null;
+        gruppen.push(gruppe);
+    }
+    return { gruppen };
+}
+function passtBedingung(version, bedingung) {
+    const c = vergleichen(version, bedingung.version);
+    switch (bedingung.operator) {
+        case '=':
+            return c === 0;
+        case '!=':
+            return c !== 0;
+        case '>':
+            return c > 0;
+        case '>=':
+            return c >= 0;
+        case '<':
+            return c < 0;
+        case '<=':
+            return c <= 0;
+    }
+}
+export function passt(version, einschraenkung) {
+    return einschraenkung.gruppen.some((gruppe) => gruppe.every((bedingung) => passtBedingung(version, bedingung)));
+}
+/** Nennt die Einschränkung selbst eine Vorabversion, dann sind Vorabversionen wählbar (E33). */
+function nenntVorab(einschraenkung) {
+    return einschraenkung.gruppen.some((gruppe) => gruppe.some((b) => b.version.vorab.length > 0));
+}
+/**
+ * Der höchste Tag, der zur Einschränkung passt, oder null. `refs` sind die Tags der Quelle,
+ * Branches gehören nicht hinein (E33). Tags ohne Versions-Schema fallen heraus.
+ */
+export function passenderRef(refs, einschraenkung) {
+    const gelesen = einschraenkungLesen(einschraenkung);
+    if (gelesen === null)
+        return null;
+    const vorabErlaubt = nenntVorab(gelesen);
+    let bester;
+    for (const ref of refs) {
+        const version = versionLesen(ref);
+        if (version === null)
+            continue;
+        if (version.vorab.length > 0 && !vorabErlaubt)
+            continue;
+        if (!passt(version, gelesen))
+            continue;
+        if (bester === undefined || vergleichen(version, bester.version) > 0)
+            bester = { ref, version };
+    }
+    return bester?.ref ?? null;
+}

package/dist/ports/harness.js

@@ -0,0 +1,6 @@
+export function kannProfile(h) {
+    return typeof h.profile === 'function';
+}
+export function kannPlugins(h) {
+    return h.plugins !== undefined;
+}

package/dist/ports/quellen.js

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

package/dist/ports/zeiger.js

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

package/dist/ports/ziele.js

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

package/dist/ports/zustand.js

@@ -0,0 +1,3 @@
+export function leererZustand() {
+    return { quellen: [], arbeitsverzeichnisse: [], bindungen: [] };
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "hmgr",
+  "version": "0.0.1",
+  "description": "Harness Manager: Skills und Plugins für AI-Harnesses verwalten",
+  "license": "MIT",
+  "author": "Tim Kaufmann",
+  "type": "module",
+  "bin": {
+    "hmgr": "dist/cli/main.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=22.6"
+  },
+  "scripts": {
+    "dev": "node src/cli/main.ts",
+    "build": "tsc -p tsconfig.build.json",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "type-check": "tsc --noEmit",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "yaml": "^2.8.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "typescript": "^5.9.0",
+    "vitest": "^3.2.0"
+  }
+}