Metadata-Version: 2.4
Name: agentmgr
Version: 0.3.0
Summary: Convert LangDock agent exports into Claude skills and manage them locally.
Project-URL: Homepage, https://github.com/equitania/agentmgr
Project-URL: Repository, https://github.com/equitania/agentmgr
Project-URL: Issues, https://github.com/equitania/agentmgr/issues
Author-email: Equitania <m.schmid@equitania.de>
License: MIT
License-File: LICENSE
Keywords: agents,claude,cli,langdock,skills
Classifier: Development Status :: 4 - Beta
Classifier: Environment :: Console
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Topic :: Utilities
Requires-Python: >=3.10
Requires-Dist: pyyaml>=6.0
Requires-Dist: rich>=13.0
Requires-Dist: typer>=0.12
Provides-Extra: dev
Requires-Dist: pytest>=8.0; extra == 'dev'
Description-Content-Type: text/markdown

# agentmgr

Convert **LangDock agent exports** into **Claude skills**, manage them locally,
and package existing Claude skills for sharing.
Wandelt **LangDock-Agenten-Exporte** in **Claude-Skills** um, verwaltet sie lokal
und verpackt bestehende Claude-Skills zum Teilen.

**Sprache / Language:** [Deutsch](#deutsch) · [English](#english)

---

<a name="deutsch"></a>

# Deutsch

## Was ist das?

Bisher liefen Agenten in **LangDock**. Ein LangDock-Agent besteht aus einem
Basis-Prompt plus beliebig vielen Markdown-Wissensdateien. Ein **Claude-Skill**
ist ein Ordner mit einer `SKILL.md` (YAML-Frontmatter + Body) und beliebigen
Begleitdateien, der über seine `description` automatisch ausgelöst wird.

`agentmgr` übersetzt das eine ins andere, hält eine lokale Bibliothek deiner
Agenten, validiert sie und installiert sie in das Verzeichnis, das Claude liest
(`~/.claude/skills`). Es kann außerdem bestehende Claude-Skills übernehmen und
als teilbares `.skill`-Paket verpacken.

## Voraussetzungen

- **Python ≥ 3.10**
- **`uv`** (Paket-/Tool-Manager von Astral) – installiert `agentmgr` isoliert.

### `uv` installieren

macOS / Linux:

```bash
curl -LsSf https://astral.sh/uv/install.sh | sh
```

macOS mit Homebrew:

```bash
brew install uv
```

Windows (PowerShell):

```powershell
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
```

Prüfen: `uv --version`. (Details: <https://docs.astral.sh/uv/>)

## agentmgr installieren

```bash
uv tool install agentmgr
agentmgr --help
```

Aktualisieren: `uv tool upgrade agentmgr` · Entfernen: `uv tool uninstall agentmgr`.

Solange noch nicht auf PyPI, aus dem lokalen Projekt:

```bash
cd agentmgr
uv build
uv tool install --reinstall ./dist/agentmgr-0.3.0-py3-none-any.whl
```

## Schnellstart

In LangDock liegen die Wissensdateien *neben* dem Export, nicht im ZIP. Lass sie
im selben Ordner – `agentmgr` hängt jede vom Prompt referenzierte Datei
automatisch an, ohne `--extra`:

```bash
# 1. Export umwandeln (referenzierte skill-no-ai-slop.md wird automatisch übernommen)
agentmgr import "No slop AI.zip"

# 2. Bibliothek ansehen
agentmgr list

# 3. Vor dem Installieren prüfen
agentmgr validate no-slop-ai

# 4. Nach ~/.claude/skills installieren, danach Claude Desktop neu starten
agentmgr install no-slop-ai
```

## Alle Kommandos

| Kommando | Zweck |
|---|---|
| `import <export.zip\|manifest.json> [--extra DATEI …]` | Einen Export in einen Bibliotheks-Skill umwandeln |
| `import-all <ordner>` | Stapelimport aller `.zip` in einem Ordner |
| `adopt <skill-ordner>` | Bestehenden Claude-Skill in die Bibliothek übernehmen |
| `list` | Bibliotheks-Agenten und Installationsstatus zeigen |
| `show <slug>` | Gerenderte `SKILL.md` ausgeben |
| `edit <slug>` | `SKILL.md` im `$EDITOR` öffnen |
| `validate <slug>` | Struktur-/Frontmatter-Prüfung |
| `install <slug> [--target ORDNER] [--force]` | In den Claude-Skills-Ordner installieren |
| `uninstall <slug> [--target ORDNER]` | Installierten Skill entfernen |
| `package <slug> [--out ORDNER]` | Teilbares `<slug>.skill`-Archiv bauen |
| `package --path <skill-ordner>` | Beliebigen Skill-Ordner direkt verpacken |
| `new <name> [-d BESCHREIBUNG]` | Neuen, leeren Agenten anlegen |
| `remove <slug>` | Agenten aus der Bibliothek löschen |
| `paths` | Bibliotheks- und Skills-Ordner anzeigen |

Hinweis: `import`/`import-all`/`adopt` nehmen Ordner/Dateien; `install`/`package`/
`show`/… nehmen einen **Slug** (linke Spalte in `agentmgr list`). Der Slug
entsteht aus dem Agent-**Namen** im Manifest, nicht aus dem Ordnernamen
(„Blogpost Generator" → `blogpost-generator`). Ordnernamen mit Schrägstrich
werden toleriert; bei Tippfehlern wird der passende Slug vorgeschlagen.

## Feldzuordnung

| LangDock `manifest.json` | Claude-Skill |
|---|---|
| `name` | Frontmatter `name` + Ordnername (slugifiziert) |
| `description` | Frontmatter `description` (steuert das Auto-Triggern) |
| `instruction` | `SKILL.md`-Body |
| Zusatz-`*.md` | Begleitdatei im Ordner (Name bleibt erhalten) |
| `conversationStarters` | `## Beispiel-Anfragen`-Block |
| `webSearch` / `imageGeneration` | `allowed-tools` |
| `model` / `creativity` / `icon.png` | kein Skill-Pendant (wird beim Import gemeldet) |

## Bestehende Claude-Skills verpacken

Ein bestehender Claude-Skill *ist* bereits das Zielformat. Zwei Wege:

```bash
# Schnell, einmalig (ohne Bibliothek):
agentmgr package --path ~/.claude/skills/mein-skill      # → mein-skill.skill

# Dauerhaft verwalten:
agentmgr adopt ~/.claude/skills/mein-skill               # übernehmen
agentmgr package mein-skill                              # bzw. install / edit
```

`adopt` zieht den Slug aus dem `name`-Frontmatter (nicht aus dem Ordnernamen) und
übernimmt `version`. Laufzeit-Abhängigkeiten (Skripte, Pakete, MCP) reisen **nicht**
mit – die müssen auf dem Zielsystem vorhanden sein.

## Konfiguration

| Variable | Standard |
|---|---|
| `AGENTMGR_HOME` | `~/.equitania/agent-manager` (Bibliothek + `index.json`) |
| `AGENTMGR_SKILLS_DIR` | `~/.claude/skills` (Installationsziel) |

`~/.claude/skills` teilen sich Claude Code und Claude Desktop. Liest deine
Desktop-Version aus einem anderen Pfad, setze `AGENTMGR_SKILLS_DIR` oder nutze
`--target`.

## Einrichtung in Claude Desktop

Die Screenshots zeigen die aktuelle Claude-Desktop-Version.

**Schritt 1 – Fähigkeit aktivieren.** Einstellungen → **Fähigkeiten** →
**Cloud-Codeausführung und Dateierstellung** einschalten („Erforderlich für
Skills").

![Einstellungen → Fähigkeiten](docs/claude_desktop_faehigkeiten.png)

**Schritt 2 – Skills liegen unter „Anpassen".** Die Skill-Verwaltung wurde aus
den Einstellungen nach **Anpassen** verschoben (Hinweis unten auf der
Fähigkeiten-Seite).

![Skills wurden zu „Anpassen" verschoben](docs/claude_desktop_skills.png)

**Schritt 3 – Anpassen → Skills.** Hier erscheinen die persönlichen Skills; per
`agentmgr install` installierte Agenten (z. B. `no-slop-ai`, `blogpost-generator`)
stehen in „Persönliche Skills". Über **„+"** → *Skill hochladen*.

![Anpassen → Skills](docs/claude_desktop_anpassen.png)

**Schritt 4 – Skill hochladen.** Der Dialog akzeptiert eine **`.zip`- oder
`.skill`-Datei mit `SKILL.md`** direkt (kein Umbenennen nötig).

![Fähigkeit hochladen](docs/claude_desktop_skills_upload.png)

Zwei gleichwertige Wege: **A)** `agentmgr install <slug>` → erscheint unter
Persönliche Skills. **B)** `agentmgr package <slug>` → `.skill` über „+ → Skill
hochladen" einspielen.

## Was man mit dem Ergebnis machen kann

Nutzen (Auto-Trigger im Chat), teilen (`.skill`), verwalten (`list`/`edit`/…),
weitere Agenten migrieren (`import`/`import-all`), bestehende Skills verpacken
(`adopt`/`package --path`) und später mehrere Skills plus MCP zu einem Plugin
bündeln.

## Grenzen

Kein Per-Agent-Modell und keine Per-Agent-Temperatur (LangDocks `model`/
`creativity` haben kein Skill-Pendant), Icon ungenutzt, echte Tool-Aktionen
brauchen MCP. Das Auto-Triggern hängt an der Qualität der `description`.

## Entwicklung

```bash
uv sync --extra dev
uv run pytest
uv build           # Wheel + sdist in dist/
```

## Changelog

- **0.3.0** – `adopt` und `package --path` für bestehende Claude-Skills.
- **0.2.2** – Slug-Toleranz (Ordnername/Schrägstrich) und „Meinten Sie …?".
- **0.2.1** – Re-Import aktualisiert standardmäßig; `--skip-existing`.
- **0.2.0** – Auto-Attach referenzierter Wissensdateien; Validator-Warnung.
- **0.1.0** – Erste Version.

## Lizenz

MIT © Equitania Software GmbH

---

<a name="english"></a>

# English

## What is this?

Agents used to live in **LangDock**. A LangDock agent is a base prompt plus any
number of markdown knowledge files. A **Claude skill** is a folder with a
`SKILL.md` (YAML frontmatter + body) and arbitrary supporting files, auto-triggered
by its `description`.

`agentmgr` translates one into the other, keeps a local library of your agents,
validates them, and installs them into the directory Claude reads
(`~/.claude/skills`). It can also adopt existing Claude skills and package them as
shareable `.skill` archives.

## Requirements

- **Python ≥ 3.10**
- **`uv`** (Astral's package/tool manager) – installs `agentmgr` in isolation.

### Install `uv`

macOS / Linux:

```bash
curl -LsSf https://astral.sh/uv/install.sh | sh
```

macOS via Homebrew:

```bash
brew install uv
```

Windows (PowerShell):

```powershell
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
```

Verify with `uv --version`. (Docs: <https://docs.astral.sh/uv/>)

## Install agentmgr

```bash
uv tool install agentmgr
agentmgr --help
```

Upgrade with `uv tool upgrade agentmgr`, remove with `uv tool uninstall agentmgr`.

Until it is on PyPI, from the local project:

```bash
cd agentmgr
uv build
uv tool install --reinstall ./dist/agentmgr-0.3.0-py3-none-any.whl
```

## Quick start

In LangDock the knowledge files live *next to* the export, not inside the zip.
Keep them in the same folder and `agentmgr` attaches every file the prompt
references automatically — no `--extra` needed:

```bash
agentmgr import "No slop AI.zip"   # referenced skill-no-ai-slop.md auto-attached
agentmgr list
agentmgr validate no-slop-ai
agentmgr install no-slop-ai        # into ~/.claude/skills, then restart Claude Desktop
```

## Commands

| Command | Purpose |
|---|---|
| `import <export.zip\|manifest.json> [--extra FILE …]` | Convert one export into a library skill |
| `import-all <folder>` | Batch-import every `.zip` in a folder |
| `adopt <skill-folder>` | Take an existing Claude skill into the library |
| `list` | List library agents and install status |
| `show <slug>` | Print the rendered `SKILL.md` |
| `edit <slug>` | Open `SKILL.md` in `$EDITOR` |
| `validate <slug>` | Structural/frontmatter checks |
| `install <slug> [--target DIR] [--force]` | Install into the Claude skills dir |
| `uninstall <slug> [--target DIR]` | Remove an installed skill |
| `package <slug> [--out DIR]` | Build a shareable `<slug>.skill` archive |
| `package --path <skill-folder>` | Package any skill folder directly |
| `new <name> [-d DESC]` | Scaffold a new agent |
| `remove <slug>` | Delete an agent from the library |
| `paths` | Show library and skills-directory locations |

Note: `import`/`import-all`/`adopt` take folders/files; `install`/`package`/`show`/…
take a **slug** (left column of `agentmgr list`). The slug comes from the agent
**name** in the manifest, not the export folder name.

## Field mapping

| LangDock `manifest.json` | Claude skill |
|---|---|
| `name` | frontmatter `name` + folder name (slugified) |
| `description` | frontmatter `description` (drives auto-triggering) |
| `instruction` | `SKILL.md` body |
| extra `*.md` | supporting file in the folder (name preserved) |
| `conversationStarters` | `## Beispiel-Anfragen` block |
| `webSearch` / `imageGeneration` | `allowed-tools` |
| `model` / `creativity` / `icon.png` | no skill equivalent (reported on import) |

## Package existing Claude skills

```bash
agentmgr package --path ~/.claude/skills/my-skill   # one-off → my-skill.skill
agentmgr adopt ~/.claude/skills/my-skill            # manage it, then package/install
```

Runtime dependencies (scripts, packages, MCP) do **not** travel with the package.

## Configuration

| Variable | Default |
|---|---|
| `AGENTMGR_HOME` | `~/.equitania/agent-manager` (library + `index.json`) |
| `AGENTMGR_SKILLS_DIR` | `~/.claude/skills` (install target) |

## Set up in Claude Desktop

Screenshots show the current Claude Desktop version.

**Step 1 – Enable the capability.** Settings → **Capabilities** → turn on
**Cloud code execution and file creation** ("Required for skills").

![Settings → Capabilities](docs/claude_desktop_faehigkeiten.png)

**Step 2 – Skills moved to "Customize".** Skill management moved out of Settings
into **Customize** (noted at the bottom of the Capabilities page).

![Skills moved to Customize](docs/claude_desktop_skills.png)

**Step 3 – Customize → Skills.** Personal skills appear here; agents installed via
`agentmgr install` (e.g. `no-slop-ai`, `blogpost-generator`) show under "Personal
skills". Use **"+"** → *Upload skill*.

![Customize → Skills](docs/claude_desktop_anpassen.png)

**Step 4 – Upload skill.** The dialog accepts a **`.zip` or `.skill` file
containing `SKILL.md`** directly (no renaming required).

![Upload skill](docs/claude_desktop_skills_upload.png)

Two equivalent paths: **A)** `agentmgr install <slug>` → appears under Personal
skills. **B)** `agentmgr package <slug>` → upload the `.skill` via "+ → Upload
skill".

## What you can do with the result

Use them (auto-trigger in chat), share them (`.skill`), manage them
(`list`/`edit`/…), migrate more agents (`import`/`import-all`), package existing
skills (`adopt`/`package --path`), and later bundle several skills plus MCP into a
plugin.

## Limitations

No per-agent model or temperature (LangDock's `model`/`creativity` have no skill
equivalent), icon unused, real tool actions require MCP. Auto-triggering depends
on the quality of the `description`.

## Development

```bash
uv sync --extra dev
uv run pytest
uv build
```

## License

MIT © Equitania Software GmbH
