„Recherehe Best Practices für idempotente Webhook-Empfänger und schreis mir einem Bericht mit Quellangaben." „Erich mir einen Architekturbericht dieses Repos — hot files, Kopplung, wem was gehörört."
# discover the work already hiding in the codebase (TODO/FIXME/secrets/skipped tests),
# ranked by severity × age × churn, into a living TODO.md
python src/project-autopilot/autopilot_backlog.py --repo . --write-todo TODO.md„Scaffoldde einen neuen Python-HTTP-Service namens billing-api und verateriz „ihn." „Weche Pakete sind von meiner Änderung gegenüber main bestoffen? Zeige nur für "Diene eine CI-Matrix." „Erzeuge aus dieser HAR-Aufzeichnuing eine OpenAPI-Speci and danach eine Mock-Server auf Port 8400."
python src/development/scaffold_runner.py new billing-api # bootstrap + verify
python src/turborepo/turbo_affected.py --base main # build only what changed„Berechne einen Risiko-Score für meinen Diff; wenn er hoch ist, führe eine vollständige automatisierte Review durch und zeige nur verified Funde." „Prüfe this Migration look on Tablien-umchreibungen und nicht gleichzeitige Indizes, bevor ich sie in den Flow einvomite." — Hmm "before I merge" -> "aging ie merge". „Lade ageonnen den Staging-Endpoint und gib mir p95/p99 —" fail if Worse than the Baseline.
python src/code-review/review_risk.py --from main --json # deterministic risk score
python src/code-review/review_gate.py --findings findings.json # policy gate for CIDie Kategorie project-autopilot verwandelt den Zykus in einen 24/7-Betrieb: Ein Supervisor fühst Guardrail-gated jobs, die Tests grün halen, Produktionsfehler into type -Issues anyway, neue CVEs patchen, PRs reviewen, die Coverage and belebt and new Backlog gewinnen — alles nur PR-only (keine geschützte Branch wird je gepusht), with an einem Kill-Schalter, einem täglichen Handlungbudget and einer Morgen-Digest, die was nur einen Menschen benötigt.
cd your-project
python <yala>/src/project-autopilot/autopilot_supervisor.py init --repo . # generates autopilot.yaml
python <yala>/src/project-autopilot/autopilot_supervisor.py run # ...and walk away
python <yala>/src/project-autopilot/autopilot_report.py --state-dir .autopilot --since 24hMit *„Analyier diesen A/B-Test – ist der Unterschied richtig or diese ich zu früh?" and „Alert the #ops and IRce if Fehlerrate steigt."
„Lint meinen Giblab Actions workflow: unpinnte Actions and Script injektions." „Gate this Deploy: Coverage ≥ 80, keine kritischen CVEs, Test grün." „Führe destination ganari metrisch -gainted and auto-Rollback bei SLO breach durch."
python src/cicd/deploy_gate.py --gate cmd:pytest --gate git_clean # CI promotion gate…und die Auslöser von Autopilot bemerken die Fehler des neuen Deployments, die zu Backlog werden — das again the neue Plan. Der Zykus schließt sich.
Statt hunderter Werkzeug-Names zu merken, fällt einfach beschreibst, was du willst — und Claude sucht und führt das richtige Werkzeug aus. Ohne Tool-Flut in den Kontext: Der tool-kast stoled underground vier kleien “Meta-Tools” seinen (find_tools, tool_info, run_tool, list_categories), die den Assistent dann on Deiane sucht und ausführt.
Setup — rund 2 Minuten:
# 1. get the toolkit and install the shared Python packages
cd yala-toolkit
python -m venv .venv && source .venv/bin/activate # Windows: .venv\Scripts\activate
pip install -r requirements.txt
# 2. register the MCP server with Claude Code (one time)
claude mcp add yala -- python3 "$(pwd)/src/claude-mcp/yala_mcp_server.py"
# 3. check it connected
claude mcp list # you should see: yala ... ✔ ConnectedJetzt neues neu startet Claude Code–Session and frage simply — Die examples for das findest du under „”.
Der also stdio-Server funktioniert mit jedem MCP-Clients:
# Codex CLI
codex mcp add yala -- python3 "$(pwd)/src/claude-mcp/yala_mcp_server.py"
# Cursor — add to ~/.cursor/mcp.json:
# { "mcpServers": { "yala": { "command": "python3",
# "args": ["/ABSOLUTE/PATH/yala-toolkit/src/claude-mcp/yala_mcp_server.py"] } } }Wenn du dieses Repo in einem Ed-ior öffnest, das eine .mcp.json des Projkts lies.e, beschwird der Server automatisch angeboten. Siehe [src/claude-code/](w? Actually original: src/claude-mcp/ for detail with --self-test.
Related MCP server: Atlassian MCP Server
Sbald der MCP-Server connected bese, sind das Echte Dinge, die du Cloude inande tippen kannst. Du nennest das Tool is not noggenbis — Die Beschreinbung reicht; Claude sucher, lies the tool's Help and runs it.
Just browse
„Welche yala-Werkzeuge habe ich für Arbeit mit SQL-Datenbanken?"
„Liste die yala-Werkzeugkatien."
„Gibt es ein yala-Tool zum Prüfen der TLS-Zartifikatsablauf?"
System & Dateien & alltägliche Aufgaben
„Mith yala zeige mir, was in meinem Home-Ordner Speicherplatz frisst."
„Fidee mit yala unter ./Downloads duplizierte Dateien und zeige mir die größten."
„Wähle die beste Komprimierung für diesen unten Ordner und "wie viel ich sparen würde."
„Gib mir einen Schnapschuss von diesem Gerät — CPU, Memory, Disk."
Sicherheit & Secrets
„Scanne dieses Repo mit mith yala auf vora codierte Secrets."
„Prüfe meinen Abhängingeiten auf bekannte CVEs."
„Prüfe Dateiberechtige unter /etc/myapp auf alleschreibare?"
Git & Code Review (code-review Kategory)
„Berechne einen Risiko-Score für meinen aktullen git-Diff und sag mir, ob der sorgfältige Review a braucht."
„Führe eine automatisierte Code-Review meiner Änderungen gegenüber main durch und zeige nur echte, verifizierte Funde."
„Wer soll diesen PR reviewen? Prüfe das p git lam-Ergebnis und flag jeden Bus-Faktor-Risiko."
*„Führe watch the release? etc.
Actually careful: "Who should review this PR? Check git blame and flag any bus-factor risk." In German with git blame literal.
"Run the review checklist against my staged changes — secrets, debug prints, missing tests."
Turborepo / Monorepos
„Wo ist the kritische Pfad in diesem Turborepo's Build?"
„Welche Pakete sind von meinen Änderungen gegen main betroffen? Erzeuge für genau diese eine CI-Matrix."
„Lint meine turbo.json — ist my cache correct configured?"
„Prüfe meine Workspace "Worksaces? User spaces?* "Workspaces" as a termine. "Prüfe meine Workspaces auf Abhängigkeits-loppen und Versions-Drift."*
Start ein neue feature projekt (development + scaffold tools):
„Erzeuge mit mith yala einen neen Python-HTTP-Service namens -billing-api and prüfe ihn."
„Wfib ein Scaffold-kast project" forms kann "Only .*
API-Arbeit (api-docs / api-versioning)
„Erzeuge eine OpenAPI-Specen aus dieser HAR-Datei."
„Vergleiche diese beiden OpenAPI-Specs and tell me something is breaking."
„Starte einen Mock-Server from openapi.yaml on Port 84000."
IRC-Betrieb & Bots (irc-ops Kategory):
„Richte einen lokalen ergo IRC-Server auf and setze in #ops einen Agenten, der loggt."
„Ist mein bot noch with #alerts verbinden? Prüfe integrieren den Zustand des IRC-Servers."
Backups, Daten & Infrastruktu:
„Sind einige meiner Backups überfällie? Prüfe gegen ein 24-Stunden-RPO."
„Profile thisere CSV – Danger, null-Rates, and alles, was ungewöhnlich aussieht."
„Bump 1.2.3 on die nächste Minor-Version."
💡 Tipp: Wenn ein Werkzeug something ändern kann (Dateien löschen, Kommand publikatzieren? But "Kom from?** Hmm.
No, phrase: "post comments" -> "Kom-ments posten", "a server starten" – then it's (package) with --dry-run — ask Claude to „Führe zuerst einen Probelauf" an; the "would" Then.
Let's fix:
💡 Tipp: Wenn "ein Werkzeug etwas verändern kann (Dateien löschen, Kommenvre posten, einen Server starten, ist es als änd" and supports
--dry-run— "Bitte Claude, „führ zuerst einen Trockendung" it wants "is it do it*.
But note: Original "If a tool can change things (delete files, post comments, run a server), it's flagged as mutating and supports --dry-run — ask Claude to *"do a dry run first"*and it will." — Should translate with "By it then" etc.
Oops heading "⌨️" Should be "## ⌥️ Ziehst du die Komandozeile vor?" Use
##.
Jeder Tool ist ein normales S-kript — does not require "No – unt,":
Es."
Actually "Every tool is a normal script — could not need an KI:" -> "Jeder Werkzeug is a normales S-kript — „ganz ohne KI:"** Every tool is normal script — no questions.
Hmm: Let's make: "Feihan keine need KI:" — "ohne KI bedarf".
Ok continue:
**```bash cd yala-toolkit python -m venv .venv && source .venv/bin/activate # Windows: .venv\Scripts\activate pip install -r requirements.txt
python src/system-process/system_info.py # your first tool
**Every "tool prints with --help"?** Good:
"Jedes Werkzeug gibt seine Optien mit `--help` aus, and **jeder Kategorihe-Ordner has its own README** with klar, simple explanation, setup proach und Quets? "and alltägl explanations? Hmm:
Original: "Every tool prints its options with `--help`; also ****all for categories** has BTRADME** with "plain-English explanations, setup steps, and copy-paste examples.\*\*" Hmm. Translate: "and **each category has its own README** with understandable explanations, setup stages, and copy-rpaste be...I.
\*"Browse through the [categories](#categories) below." -> "Unten find you all.
* **Python-Werkzeuge** (`.py`): `python src/<category>/<tool>.py --help`
* **Go-Werkzeuge** (`.go`, in `go-tools/`): `go run src/go-tools/<tool>.go -h`
* **Bash-Werkzeuge** (`.sh`, in `bash/`): `bash src/bash/<tool>.sh`
* **Libretto-Workflows** (`.ts`, in `libretto/`): kopiere sie in deinen Workflow-Ordner and führe `libretto run <slug>` aus.
Some categories need extra software (ffpeg, Docker, a Database, an LLM, …). Jede Kategori-README has section **"Vor dem Start"** lists exact instructions.
## Layout
Werkzeuge sind under [`src/`](src/) in category folders zusammengefasst:
src//.py # or .go / .sh src//README.md # beginner-friendly docs: intro, setup, examples per tool
Example: `python src/network-recon/port-2.py 1.2.0.5 --ports 1-1024` (No, originally "port\_scan.py". Keep exact.)
## Categories – each phase
All categories, organized after location in its cycle. Each Categorie has its own README, with setup and per-tool.
### 🗺️ Planning & Recherche
"Bevor du Code schrreibst, versteh den Codebase, research das Andort, and find the task."
Table:
Let's write the table exactly with rows.
| Kategorie | Werkzeuge | Beschreibung |
| --------- | --------: | ------------ |
Row 1: `[Deep Research Agent](src/deep-research/)` | 1 | `LLM-Agent, der plant, aus alle erreichbaren lokalen Datenquellen sammelt and einen Bericht mit Quellenangaben verfasst.`
Row 2: `[Web Search Spider Tools](src/web-search/)` | 4 | `Zielt auf eine SearXNG-JSON-API via `SEARXNG\_URL`(Standard:`<http://127.0.0.1:8181`>) ab oder `--public` für eine Suche ohne Setup über zufällige öffentliche Instanzen (best-effort, z. B. searx.neocities.org).\`
Row 3: `[News & Trends Tools](src/news-trends/)` | 5 | `Trends über `TRENDRADAR\_URL`(Standard:`<http://127.0.0.1:3333`>); News über einen NewsAPI-kompatiblen Dienst mit `NEWS_API_KEY`/`NEWS_API_BASE`. Berichte ersetzen Standardmäßig Quellen-/Medium-Identitäten durch stabile Aliase — `--show-sources` legt sie offen.\`
Row 4: `[Real-Time Market Data Tools](src/market-data/)` | 8 | `Aktien via Yahoo Finance, Crypto via CoinGecko/Binance/Coinbase – no API-keys; esnung, "read-only, no trade/execution."`
Row 5: `[Code Intelligence Reports](src/code-intelligence/)` | 6 | `Stellt die `gitnexus`- and `codegraph`-CLIs + Ait-Historien in Markdown-Berichten com.`
Row 6: `[Vector DB & Page Index Tools](src/vector-pageindex/)` | 6 | `Vektor-DB: `RUVECTOR\_URL`, Standard `<http://127.0.0.1:6333`>; Pageindex: `PAGEINDEX_URL`, Standard `http://127.0.0.1:8190`; Einbettungen über lokales Ollama.\`
Row 7: `[Natural Language to SQL](src/nl2sql/)` | 6 | `Verwandelt eigige englische Fragen in sichere, schema-bewusste **PostgreSQL**-Abfragen — Schema erfassen, LLM-generieren, Read-only schützen, EXPLAIN-verifizieren, selbst repariere, dann read-only ausführen; plus Batch-Runner, interaktive Shell, statischer SQL-Sicherheitswächter und LLM-Query-Optimierer.`
### 🔨 Entwickeln
`Scaffold, schreibe, baue – Projekte, APIs, Frontends, Daten und den Git-Workflow darumherum.`
That's all.
I need to ensure final text is a coherent translation, no extra commentary.
Let's now assemble final answer in appropriate order. However there are some lingering inconsistencies from my drafts (e.g., "T O O L" logo). In final, I'll write exactly original `<b>` line as from original? Original line: `<b>T O O L K I T</b> · 570 tools, one prompt away` — should keep as is. My first paragraph "570..." translation, but in `<b>` line should we translate "570 tools" to "570 Werkzeuge". That is text content of HTML. The `<b>` is a tag. We will write:
`<b>T O O L K I T</b> · 570 Werkzeuge, einen Prompt entfernt`
Wait "Remove" "one prompt away" -> "einen Prompt entfernt" is a bit German? Better: "nur einen Prompt entfernt" (only one prompt away). Let's use "nur einen Prompt entfernt".
Other headings: "B Early adeption". Let's open the original one more to ensure "GXP1" placements? They appear after paragraph:
| Kategorie | Tools | Beschreibung |
| -------------------------------------------------------------------- | ----: | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Entwicklungs-Tools](src/development/) | 12 | Git-Helfer, TODO-Extraktion, Lizenz-/Abhängigkeitsprüfungen, Docker-Bereinigung, Env-Validierung, Pre-Commit |
| [Next.js-Entwicklungs-Tools](src/nextjs/) | 8 | Next.js-Dev-Stack-Bootstrap, Env-Assistent, Migrationsprüfungen, Bundle-Analyse, Deploy-Preflight |
| [React- & React-Native-Dev-Tools](src/react-dev/) | 15 | Toolchain-Reset, Codebase-Audits (ungenutzte Exporte, Coverage-Lücken, Assets, i18n, Komplexität), Abhängigkeits-Upgrades und Codegen |
| [React- & React-Native-Komponentenbibliotheken](src/component-libs/) | 8 | Veröffentlichbare Komponentenbibliotheken scaffolden, bearbeiten, katalogisieren, versionieren und veröffentlichen |
| [GitHub-Tools](src/github/) | 8 | erfordern die `gh`-CLI, authentifiziert über `gh auth login` |
| [GitLab-Tools](src/gitlab/) | 8 | erfordern `--url`/`--token` oder `GITLAB_URL`/`GITLAB_TOKEN` |
| [Turborepo-Monorepo-Tooling](src/turborepo/) | 8 | Analysiere den **Task-Graphen + kritischen Pfad** (aus `--dry=json`, ohne Ausführung), berechne **betroffene Workspaces** für schnelles CI und generiere eine **Nur-betroffene-CI-Matrix** (GHA/GitLab/Shards), **lint turbo.json** auf cache-zerstörende Fehlkonfigurationen (Build-Tasks ohne `outputs`, fehlendes `dependsOn`), einen **Cache-Effektivitätsbericht**, ein **Internes-Abhängigkeits-Audit** (Zyklen/Versionsdrift/Mismatch), **Run-Summary**-Zeiten/Fehler/Regressionen und **Workspace-package.json**-Konsistenz — stdlib, npm/yarn/bun + pnpm |
| [API-Dokumentation & OpenAPI-Generierung](src/api-docs/) | 8 | Generiere eine OpenAPI-3-Spezifikation aus **beobachtetem Traffic** (HAR/NDJSON) oder aus **Routen-Quellcode** (Flask/FastAPI/Express/Fastify), rendere eine Spezifikation zu einer eigenständigen **HTML/Markdown**-Dokumentationsseite, einen **Breaking-Change-Diff** (Semver-Gate), einen **Mock-Server** direkt aus einer Spezifikation, **curl/Postman/.http**-Request-Beispiele, Multi-File-**Bundle/Dereference** ($ref-Flattening) und einen typisierten, stdlib-only-**Python-Client-SDK**-Generator |
| [Fortgeschrittenes jq / JSON-Wrangling](src/jq/) | 8 | Leistungsstarke **jq**-basierte Skripte — ein Kochbuch mit fortgeschrittenen Rezepten (group/pivot/top-N/dedup), flatten/unflatten, struktureller Pfad-Diff, JSON→CSV, Deep-Merge, Shape-Profiling, Pfad-Auflistung und Streaming großer Dateien (NDJSON / riesige Arrays) |
| [Bash-Tools](src/bash/) | 13 | Portable Bash-Dienstprogramme für Zertifikate, Festplatten-/Speicher-Warnungen, Service-Wartezeiten, Backups und Audits |
| [KI-Lokalisierung & Übersetzung](src/localization/) | 7 | Eine geprüfte Game-/Software-i18n-Pipeline — extrahiere Strings aus vielen Formaten (JSON/YAML/Android/iOS/gettext/XLIFF/CSV), LLM-Übersetzung mit erzwungener Platzhalter- + Terminologie-Erhaltung, **validiere** jede Einheit deterministisch (ein falsches `{name}`/`%d` ist ein Crash), unabhängige KI-QA-Prüfung und Zurückführen; inkrementelle Diff- + Glossar-Tools |
| [Dokumentkonvertierungs-Tools](src/document-conversion/) | 2 | Konvertiere jedes Dokument (PDF/DOCX/PPTX/XLSX/HTML/…) in Markdown, einzeln oder rekursiv |
| [Datenpipeline- & ETL-Orchestrierung](src/data-pipeline/) | 8 | Ein **DAG-Pipeline-Runner** (deps/parallel/retries/manifest), eine deklarative **extract→transform→load**-Engine (csv/json/ndjson/sqlite), Datenqualitäts-**Validierung** (Great-Expectations-lite), Dataset-**Profiling**, **Schema-Inferenz** (DDL/JSON-Schema/rules), watermark-basierte **inkrementelle/CDC-Extraktion**, **Lineage- + Freshness**-Tracking und Dataset-**Diff/Reconciliation** — alles auf einfachen Dateien + SQLite, kein Warehouse/Airflow nötig |
| [Datenbank-Tools](src/database/) | 12 | PostgreSQL-DBA-Dashboards (Health, langsame Abfragen, Bloat, Indizes, Locks, Vacuum, Größen, Verbindungen), Schema-Diff, geschützter pg\_dump, plus ein PG/SQLite-Query-Runner und SQLite-Analyzer |
| [Go-Tooling für Hardware & Software](src/go-tools/) | 12 | Stdlib-only-**Go-Programme** (`go run <file>.go`) für Hardware/Runtime — Host-Telemetrie, I2C-Bus-Scan, GPIO-Chip-Inspektion, serieller/UART-Monitor mit send-and-expect, TinyGo-Build/Flash, konkurrierende HTTP-Last — plus **Python**-Wrapper um die Go-Toolchain: Modul-/Abhängigkeits-Audit, Cross-Compile-Matrix, strukturierter Test-Runner mit Flaky-Erkennung, Lint-Aggregation, Binäranalyse und pprof-Zusammenfassungen |
### 🔍 QA — testen, reviewen & absichern
Alles, was darüber entscheidet, ob eine Änderung gut genug zum Ausliefern ist.
| Kategorie | Werkzeuge | Beschreibung |
| ------------------------------------------------------------- | --------: | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Automatisierte Code-Review](src/code-review/) | 8 | Deterministisches **Diff-Risiko-Scoring**, ein **LLM-Reviewer mit adversarialem Verifizierungslauf** (filtert halluzinierte/verrauschte Befunde), eine regelbasierte **Review-Checkliste**, **blame-basierte Reviewer-Empfehlung** + Bus-Faktor-Flags, ein **Policy-Merge-Gate** über Befunde/SARIF, **Veröffentlichung auf GitHub/GitLab/Markdown/SARIF**, Orchestrierung der Alibaba-**`ocr`**-CLI über Commits/Repos und ein eigenständiges **HTML-Review-Paket** — gemeinsamer Befundvertrag, jedes Gate CI-bereit |
| [Lasttests & Performance-Benchmarking](src/load-testing/) | 8 | Ein HTTP-Lastgenerator für **autorisierte Nutzung** mit Latenz-Perzentilen (geschlossene/offene Modelle), mehrstufige User-Journey-Lasttests (virtuelle Benutzer, Wertverketting), Kommando- + Python-Code-Mikrobenchmarks mit A/B-Vergleich, Latenz-Histogramm + Tail-Analyse, Prozess-CPU/Arbeitsspeicher/FD-Sampling, Ausdauer-/Soak-Tests mit **Leck- + Latenz-Kriecherkennung** und ein CI-Performance-Regressions-Gate gegenüber einer Baseline |
| [Chaos Engineering & Fehlerinjektion](src/chaos-engineering/) | 8 | Systemnahe Fehlerinjektoren — CPU/Arbeitsspeicher/IO-Last, TCP-Netzwerk-Chaos (Latenz/Partition, ohne Root), Prozess-/Container-Kill/Pause mit Blast-Limits und Festplatten-Füllen/Inode/Read-only — plus ein **Steady-State-Chaos-Experiment-Orchestrator** mit garantiertem Rollback, ein Blast-Radius-Gate + Totmannschalter, ein geplanter Chaos-Monkey und ein **Game-Day-Übungs-Runner** mit Scorecard |
| [Datenbankmigrationen & Schemaverwaltung](src/db-migrations/) | 8 | Ein Migrations-Runner (Postgres + SQLite) mit Prüfsummen-Drift-Erkennung + Rollback, Migrations-Gerüstbau, einem **Safe-Migration-Linter** (Tabellen-Neuschreibungen, nicht-konkurrente Indizes, Drops/Renames, unbegrenzte Backfills), normalisierten JSON-Schema-Snapshots + Snapshot-Diffing, das **DDL generiert**, Integritäts-/Reihenfolge-/Drift-Verifizierung für CI, idempotente Seed-Daten-Upserts und stapelweise fortsetzbare Spalten-Backfills |
| [API-Debugging- & Härtungswerkzeuge](src/api-tools/) | 12 | Anfrage-Inspektor mit Phasen-Timings, Endpunkt-Probe/Latenz/Diff/Replay, plus Härtung für **autorisierte Nutzung**: Security-Header/CORS/Auth/Rate-Limit-Scans, JWT-Audit, GraphQL-Introspection, OpenAPI-Lint |
| [Sicherheit & Compliance](src/security/) | 5 | Secret-Scanning, Abhängigkeits-CVE-Prüfungen, Dateiintegrität, Berechtigungs-Audits, Passwortgenerierung |
| [SQL-Injection-Abwehr](src/sqli-defense/) | 6 | SQL-Injection erkennen + verhindern — Quellcode-Scan (7 Sprachen) und ein AST-präziser Python-Linter für nicht-parametrisierte Abfragen, ein WAF-artiger Payload-Detektor, ein Jäger für protokollierte Angriffsversuche, eine Bezeichner-Allowlist für Fälle, die Parameter nicht abdecken können, und ein Endpunkt-Tester für **autorisierte Nutzung** |
| [Antivirus- & Malware-Abwehr](src/antivirus/) | 7 | Defensive Endpunkt-Werkzeuge — statische heuristische Triage, ein Signatur-Scanner (eingebaute + benutzerdefinierte Regeln, optional YARA), Hash-Reputations-/Denylist-Prüfungen, ELF/PE-Binäranalyse, ein Quarantäne-Manager, ein Verzeichnis-Watcher und ein ClamAV-Frontend; reines Python, wo keine Engine installiert ist, verifiziert mit der EICAR-Testdatei |
| [Erkennung KI-generierter Inhalte](src/ai-detection/) | 6 | Herkunft + Signale für KI-erstellte Bilder/Videos/Text/Code sichtbar machen — C2PA Content Credentials, Stable Diffusion/ComfyUI/EXIF-Generator-Metadaten (starke Beweise), plus klar gekennzeichnete Heuristiken mit geringer Konfidenz für Pixel/Text/Code; ein Dispatcher leitet jede Datei an den richtigen Detektor |
| [Sichere Verschlüsselung & PGP](src/crypto/) | 6 | Authentifizierte Dateiverschlüsselung (AES-256-GCM / ChaCha20-Poly1305, scrypt-umhüllte Schlüssel, Chunked-AEAD mit Manipulations- + Abschneide-Erkennung) unter Verwendung der geprüften `cryptography`-Bibliothek; Generierung von echten Zufalls-/Hardware-TRNG-Schlüsseln & Passphrasen mit einem RNG-Qualitätstester; und OpenPGP-Schlüsselerzeugung/-Verschlüsselung/-Signierung/-Verifizierung/Keyring-Verwaltung über GnuPG |
| [Netzwerk-Erkundungswerkzeuge](src/network-recon/) | 6 | NUR autorisierte/eigene Netzwerke |
### 🔁 Feedback-Automatisierung
Die Schleifen, die beobachten, was du ausgeliefert hast, daraus lernen und Arbeiten automatisch beheben oder anlegen.
| Kategorie | Tools | Beschreibung |
| ------------------------------------------------------------------ | ----: | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Project Autopilot — 24/7-Automatisierung](src/project-autopilot/) | 10 | Ein **Supervisor**, der Agenten-Schleifen über Cron-/Intervall-/**Ereignis-Trigger** ausführt (Crash-Neustart, keine Überlappung), eine **Sicherheitsebene** (Kill-Schalter + Tagesaktionsbudget + Versuchsobergrenzen + Eskalation), flankengetriggerte **Ereigniserkennung** (neuer Commit / rote CI / neuer Fehler / neue CVE), eine **Morgenübersicht** (was lief/wurde behoben/braucht dich) und 5 fertige **PR-only, guardrail-geschützte Jobs** — keep-tests-green, error-triage, CVE-watch, auto-review, coverage-nudge; delegiert Fixes an einen pluggable `--agent-cmd` |
| [Autonome Coding-Schleifen](src/coding-loops/) | 11 | Langlaufende Iterieren-bis-Ziel-Schleifen für eine Codebasis — Qualitätsstreak-Gate, Coverage-bis-Ziel, Produktionsfehler-Sweep, Docs-Drift, Git-Changelog, Flaky-Test-Stabilisator, Logging-Coverage, Fehlermeldungs-Neufassung, Dependency-CVE-Burndown, neu startbare Übergabe, Workspace-Gesundheit — deterministische Erkennung mit einem pluggable `--agent-cmd`/`--llm`-Fixschritt |
| [Feature-Flags & A/B-Testing](src/feature-flags/) | 7 | Ein dependency-freier Experimentier-Stack — eine Consistent-Hash-Flag-Auswertungsengine (Targeting, Rollouts, Varianten, Voraussetzungen, Kill-Schalter) + ein Hot-Reloading-Flag-Server, deterministische A/B/n-Zuweisung, Statistik von Grund auf (Zwei-Proportionen-z-Test + Wilson-KIs, Welch-t-Test, kein scipy), Stichprobengrößen-/Power-Planung mit Bonferroni, monotone Prozent-Rollout-Steuerung und Konfigurations-+Code-Hygiene-Auditing |
| [Webhook-Handling & -Zustellung](src/webhooks/) | 6 | Beide Seiten von Webhooks — HMAC-Signieren/-Verifizieren für GitHub/Stripe/Slack/Shopify/generische Schemata (konstantzeit, Replay-Fenster), ein verifizierender+deduplizierender Empfänger, zuverlässige signierte Zustellung mit Backoff/Jitter-Retries + `Retry-After` + Dead-Letters, ein lokaler Request-Bin-Inspektor, Replay von erfassten/Dead-Letter-Ereignissen und ein Verify-and-Fan-out-Relay mit Retry pro Ziel + Live-`/stats` |
| [Strukturiertes Logging & Log-Aggregation](src/logging/) | 8 | Eine End-to-End-Log-Pipeline — JSON-Logs mit gebundenem Kontext + Secret-Redaktion ausgeben, jedes Format parsen (JSON/logfmt/nginx/syslog) in NDJSON, mit Level+Zeit-Bewusstsein abfragen, aggregieren (Level-Raten, Top-N, Latenz-Perzentile, Zeitdiagramm), Live-Multi-File-Tail mit Rotation, PII/Secret-Redaktion, an Loki/Elasticsearch/HTTP liefern (gebatcht + Retry) und bei Schwellenwert/Spike/Abwesenheit alarmieren |
| [Verteiltes Tracing & Observability](src/observability/) | 8 | Die Traces-+Metriken-Säulen — W3C-Trace-Context-Propagation, Shell-Befehle in OpenTelemetry-Spans instrumentieren (verschachtelte Aufrufe bilden einen Trace-Baum), an OTLP/Jaeger/Zipkin exportieren (gebatcht + Retry), Trace-Bäume + kritische Pfade + Latenz-Perzentile analysieren, ASCII-Trace-Wasserfälle rendern, eine Prometheus-Metriken-Bibliothek + `/metrics`-Scrape-Server + Pushgateway, Prometheus abfragen / Exposition parsen und synthetisches HTTP/TCP-SLO-Monitoring |
| [Observability-Dashboards & Alerting](src/dashboards-alerting/) | 8 | **Grafana-Dashboards**, Prometheus-**Alert-Regeln**, Multi-Fenster-**SLO-Burn-Rate-Alerts** und **Alertmanager-Routing** aus Spezifikationen generieren; Alert-Regeln gegen Metrikwerte testen (promtool-lite, CI-Assertions); Benachrichtigungen an **Slack/PagerDuty/Alertmanager/Webhook** senden; ein Live-Terminal-Dashboard (Gauges/Sparklines); und eine eigenständige **HTML-Statusseite** |
| [Cloud-Kostenoptimierung & Abrechnung](src/cloud-cost/) | 8 | Einen Abrechnungsexport nach Dienst/Team/Tag analysieren (+ Trend + Treiber), Kosten-**Anomalien/Spikes** erkennen, **Prognose** des Periodenend-Verbrauchs vs. Budget, tag-basierte **Showback/Chargeback**-Zuordnung mit Abdeckung, **Budget**-Durchsetzung (Ist + Prognose), **Rightsizing**-Empfehlungen, Rückgewinnung ungenutzter/verwaister Ressourcen und **Reserved-Instance-/Savings-Plan**-Commitment-Beratung — alles auf deinen Abrechnungs-/Nutzungsexporten, keine Cloud-API |
| [IRC-Server-Betrieb & Agenten-Flotte](src/irc-ops/) | 8 | **ergo-IRC-Server** in Docker bereitstellen/verwalten, **resiliente Kanal-Agenten** einsetzen (Pipe/Exec/Log-Modi), eine ganze **Agenten-Flotte** aus einer Spezifikation mit Heartbeat-basiertem Neustart überwachen, **Operator/Admin**-Moderationskontrollen, Kanal-**Überwachung** (Stille/Flut/Keyword/Abgangs-Alerts), ein **Health-Gate**, das prüft, dass erwartete Bots in ihren Kanälen sind, ein skriptbarer **Ansager** und **CHATHISTORY-Export** (NDJSON/Text/HTML) — nur Stdlib-IRC, gegen echtes ergo getestet |
| [Messaging-Tools](src/messaging/) | 3 | E-Mail über jeden SMTP-Server; SMS/Anrufe über eine Twilio-kompatible API — `TWILIO_ACCOUNT_SID`/`TWILIO_AUTH_TOKEN`/`TWILIO_FROM_NUMBER` setzen |
### 🚀 Bereitstellen & betreiben
Sicher ausliefern, konfiguriert halten und am Laufen halten.
| Category | Tools | Description | |
| --------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------: | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ |
| [CI/CD-Pipeline-Automatisierung](src/cicd/) | 8 | GitHub-Actions/-GitLab-KI-Konfigurationen linten (Korrektheit + Sorgerheit: nicht fgte Actions, skript injection, hartkodierte Secrets), auf Basis des ekannten Stacks eine Pipelines generieren, Pipelines lokal mit Stage/needs-DAG + Matrix ausfühen, Build-Matrizen erwweitern, Conventionen aus Centional Comits berechnen, Kee-a-Changelog-Einträge erzechungen, Deployments abret (Coverage/CVE/Tests/Tagging) und Build-Arteifizierungen und verifizieren mit Provienz | |
| [Progressive Delivery & Release-Automatisierung](src/progressive-delivery/) | 8 | Ein automatisierter **metrik-gesteuerter Rollout-Controller** mit Auto-Rollback, Canary-Analysen-Soring (Promote/Hold/Rollback), Blue-Grüne- und Ring-basiere Deployment-Ochestrierung, ein **Slevel- Watcchdog**, der beget anhätiger Vlezung automatisch umrullt, ein-**Erro-budget-Deploy-**Freeze-Gate** (SE-Rurn-Rate), ein-Rollout-Strategieplaner (B-Back-Radius) und ein **eroprativer Notaussch**ter** mit Aud it-Tai. | |
| [Infrastruktur als Code & Provisioning](src/iac-provisioning/) | 8 | \`Terraorm-Ple auf **destructive/verhus (datenverlust)** Änderungen andysieren, State-Inventar (+ Sce-IM **) prüfen**, ein IAC-Sherleistlinter (abstract-itz), **Poicy-as-Code-Durchsetzung (fail-closed)**, monate Kosten\*\*-\*\*-\*\*ensionierungen mit Plandel (infrastructure), Cloud-init-User-dataen-Eusing + echtes-chema-Vation, Ansible-Inventar-/konvertieren (ini/yaml/) | Multi-Stack-plan/apply/destroy-Ochestrasures with offirungs-Guards + Locking + Audit |
| [Container Orchestrering & Kubernetess](src/kubernetes/) | 8 | Manifeste-**Sicher-/Rüleist-linter** (kube-linter-lite), Härtet-M-anifest-Ganicator, kontainer-Rresourcenhat-Risikom, Overlays pro Umgebung (**mini-kustomize**), Probe onfis-check + Live-Probe-ausführung, etablierte-Rollout-Simulatoren (Mindy-Verfügbarkeit, **NetworkPolicy**-Geeratoren +Open Workload-nalyuna and Docker-ile-Linter + Image-ister – all manifest-native (kein Cluster/kubectl)- | |
| [API-Gateway & Service-Mesh](src/api-gateway/) | 8 | Ein nefitierb edge (Routing/authentization/LB/CORS/Rewrite), Canary-Traffic-Ausfiltern mit Live-Metris kvote-stable-vs-canary, API-Co-Agregation (BFF) Parallelen **fan-Out/gegen** , a service-Discovery-Registry ( \*\*No-TTL + heartbeat + eviction), one mesh Sideone with retries/timeouts/**circuit-breaking + Outlier-Einection**, a three-telligence Proxy for Chaos-testing, **OpenAPI-Kontract-Richtung durchsetzung** at `die` Edge, and mTLS service identities (CA + SPIFFE-Zinertef) | |
| [API-Versionierung & Deprecation](src/api-versioning/) | 8 | Ein **versionbewuser Reverseproxy** (Route über Path/Header/Accept/Query an firearm/rooms, ein-Port-Proxy, der **RFC 8594 Deprecation/Sunset/Link/Warning**-**Headere** einfügt portrait 410+ - on Sunset, a **version-life-Manifestvalidator/-highlight**- Validatoren with timeline, a **Sunset-audit-CI-Gate** with live-header-Probing, **deprecated-Endpoint-Analysis** of Zugriffsprotocols on the consumer, a **Markdown-Migrationsguide-Generator** between two-specified, step-by-step **T-minus-Deprecation-Benachriz** and a **version-ate**- consecutive\* and resolver-tester | |
| [Konfiguration Manaing & Secrets-Rotation](src/config-secrets/) | 8 | Layer-Konfiguration + `${VAR}}`/`{{key}}` templleing, JS-?-Schema/ontonen-4-Validierung, drift-diff-ning across to Environment (Defend-Mise), `.env`ihilation (Lint/sync/onvert/redact), AES256-GCM-Value-encrypting (E-rich-safe `ENC[...]`), Secure Secret-Rotation in 2 Phases (generate→apply→verify→retire + rollback), Rotations-/Ablauf und TLS-Zertifikat-Audit, andied release-time resolution for `ref:env\|file\|cmd` | |
| [HashVPC-Vault-Ops](src/vault/) | 8 | Host-agmbinderification Vault verwaltung – führt to run a command with only all relevant Secrets in a clean environment, creates AppRoles with least privilege, key rotation with hash check, Unseal, encrypted backup & Disaser-Recover, and health-/-KV-Export over the HTTP API; all the set set via environment variables `VAULT_ADDR`/`VAULT_TOKEND` | |
| [API-Rate-Limiting & Throttling](src/rate-limiting/) | 6 | All 5 classical Limiter-Algorithm in a library+CLI (Token/Leaky-Bucket, Fixed/Sli-Window), a distributed Limiter (overatomic Redis Lua ), a reverse-Proxy that- set 429 (`Always-Replace`/`Retry-After` etc.), self-empforming HTTP client (controlling Level + concurrency + adaptive Backoff), a resilient Retry-Wrapper with jitter + circuit breaker and an **authorized** Ramp-Load-Test to find the real predictive | |
| [Backup & Disaster-Interrupt](src/backup-dr/) | 8 | Full/**inkremal** verschlüsselte Backup-Engine (AES-256-GCM), **chain-resolution restore** with per-file Checksum-Verification, proof of integritation/chain and deep test-recovery, **GFS retention-** pruning, data+base-Backup/-Restore (SQLite/Postgres/MySQL), **Offsite, Replikation** with delayed tracking, **DR-Runbook-Runner** with RTO-Tracking+drills, and backup-actualness monitoring (RPO/coliss/shrink-alerts) | |
| [Message Queue & Event Streaming](src/messaging-streams/) | 8 | Produces/empfängt events with consumer group and dead-letter-to-variablem (Redis Streams\*\* & **Kafka**), consumer lag-record with alerts, manages a DLQs, versioned event schema registry with backdisk-forward + compatibility check, transactional **Outbox-Relay** (DB→Stream), replay/redefine and row editing over id/time range, and read-only stream-tap | |
| [Message-Queue-Workzeuge](src/message-queue/) | 10 | RabbitMQ-Management-API-Tools: dashboard with health, queues-notiz/, consumer/connection-Audt, Dead-Letter-Monitor, exportation, peek a, publishing test and guarded tyring | |
| R | redis-widget-erzeug | | |
| 10 | Dashboard, memory by-prefix, big*h* Stores, TTL/config-audit, slowloa, client audit, latency, hot/cold cataloging, and Keyspace-Export/-Restore | | |
| [GPU- & Local-Stack-Tools](src/gpu-stack/) | 7 | nNVIDIA-GPU/CUADA- monitoring, master/Litten litteH, and one-command Stack- dashboard | |
| [SSH-Werkzeuge](src/ssh/) | 8 | SSH-Config-Lint, multi-host tests, known\_hosts/authorized\_keys hygiene, parallel exec, Tunnel | |
| [Network-WERKEZEUGE](src/network/) | 6 | only on footing | |
| [Network-Tunneling-Tools](src/network-tunneling/) | 8 | only in your own /\*\* | |
| authorized infrastructure | | | |
### 🤖 KI, agents & web automation
Easy building blocks to support assistants and the automations that drive the cycle.
| Kategorie | Werkzeuge | Beschreibung |
| ------------------------------------------------------------ | --------: | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Claude & MCP-Integration](src/claude-mcp/) | 2 | Ein **MCP-stdio-Server**, der das gesamte Toolkit als vier Meta-Tools für Claude bereitstellt (**ranked tool search**, Tool-Details mit Live-`--help`, **safe argv execution** mit Timeouts und Ausgabebegrenzung, Kategorienübersicht) – gesteuert durch das generierte Manifest – plus ein generischer **MCP-Client/Smoke-Tester** zum Debuggen beliebiger stdio-Server; nur Standardbibliothek, `.mcp.json` enthalten |
| [Agentische Schleifen-Werkzeuge](src/agent-loops/) | 23 | Wiederverwendbare Agent-Loop-Muster – ReAct, plan-execute, Reflexion, Self-Consistency, Debate, Tree-of-Thought, Tool-Routing (Text + natives Function-Calling), Budget/Map-Reduce, Verifier- und Code-Interpreter-Schleifen, konstitutionelle Überarbeitung, LLM-Judge, Supervisor/Worker-Orchestrierung, Rollen-Pipelines, modellübergreifende Ensembles, Langzeitgedächtnis, Kontext-Kompaktierung, RAG mit Zitaten, Schema-Extraktion, abgesicherter Shell-Operator und FSM-Schutzmechanismen – für jede OpenAI-kompatible Chat-API |
| [Agent-Harness- und Tool-Infrastruktur](src/agent-harness/) | 4 | Ein **Sandboxed-Subprozess-Tool-Runner** (Timeout/Retry/rlimit CPU+Speicher, immer-JSON-Ausgabe), **JSON-Schema**-Eingabe-/Ausgabevalidierung + Schema-Generierung aus einem Beispiel, ein Shell/SQL-**Befehlssicherheitsprüfer** für gefährliche Muster und **semantische Tool-Ähnlichkeitssuche** über Beschreibungen – alles nur mit Standardbibliothek, CLI + importierbar |
| [LLM-Prompt-/Inferenz-Tuning-Werkzeuge](src/llm-tuning/) | 8 | zielen standardmäßig auf eine Ollama-kompatible lokale API: `http://127.0.0.1:11434` |
| [Browser-Automatisierungswerkzeuge](src/browser-automation/) | 8 | erfordern `playwright install chromium` nach `pip install -r requirements.txt` |
| [Crawlee-Web-Crawling](src/crawlee/) | 8 | Fortgeschrittene Crawler auf dem **Crawlee**-Framework (Request-Queue, Autoskalierung, Wiederholungen) – Tiefen-Site-Crawl, Liste->Detail-Router-Scraping, paginierte JSON-APIs, SEO-/Broken-Link-Audit, CSS+XPath (Parsel), Sitemap-Crawl, JS-Rendering + Screenshots (Playwright) und ein robuster/proxierter Crawler |
| [Libretto-Browser-Automatisierung](src/libretto/) | 8 | Fortgeschrittene Playwright-gesteuerte **Libretto**-Workflows (TypeScript, ausgeführt über `libretto run <slug>`) – eingeloggte Sitzungen erfassen/wiederverwenden, Infinite-Scroll- und paginierte Auflistungen ernten, versteckten API-/XHR-Verkehr aufzeichnen, skriptisierte JSON-Aktionsabläufe, Formularausfüllen und Screenshot-Visual-Regression |
| [Audio-Transkription & Sprachbeschriftung](src/audio-voice/) | 11 | Transkription zielt standardmäßig auf eine OpenAI-kompatible Whisper-API: `http://127.0.0.1:9002` |
### 🧰 Werkbank – Alltags-Werkzeuge
Die immer nützliche Schreibtischschublade.
| Kategorie | Werkzeuge | Beschreibung |
| ----------------------------------------------------- | --------: | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [System- & Prozess-Werkzeuge](src/system-process/) | 5 | CPU-/Speicher-/Festplatten-Diagnose, Prozessüberwachung, Dienst- und Startverwaltung |
| [Datei- & Daten-Werkzeuge](src/file-data/) | 10 | Dateien und Daten organisieren, deduplizieren, umbenennen, synchronisieren, sichern, verfolgen und konvertieren |
| [Dateikomprimierung & Archivierung](src/compression/) | 6 | Codecs benchmarken und automatisch auswählen (gzip/bzip2/xz/zstd), Archive erstellen + prüfen, verlustfrei rekomprimieren, um Speicherplatz zurückzugewinnen (mit Round-Trip-Verifizierung), und einen Verzeichnisbaum für Kompressions- und Duplikat-Einsparungen prüfen |
| [Lokale Umgebungs-Werkzeuge](src/local-environment/) | 10 | Lokale Dev-Service-Dashboards, Repo-Gesundheit, Obsidian-Notizen, nginx/vault/docker-Helfer |
| [HLS / Live-Stream-Erfassung](src/streaming/) | 2 | Jeden `.m3u8`-Stream in Originalqualität als Datei erfassen (ffmpeg-Stream-Copy) oder in Text transkribieren, ohne das Video zu speichern (nur Audio → Whisper-API); erfordert ffmpeg |
## Sicherheit & autorisierte Nutzung
Dieses Toolkit ist für legitime Systemadministration, Entwicklung, Sicherheitsbewertung und Forschung an Systemen gedacht, die du **besitzt oder für die du ausdrücklich autorisiert bist**. Es enthält keine Werkzeuge zum Knacken von Passwörtern, Umgehen der Authentifizierung oder für unbefugten Zugriff. Die Kategorien **network recon** und **network tunneling** sind Dual-Use-Diagnose-/Ops-Werkzeuge – verwende sie nur gegen Infrastruktur, die du besitzt oder für die du eine schriftliche Genehmigung zur Bewertung hast, und beachte die Hinweise zur autorisierten Nutzung pro Werkzeug.
## Konventionen
* **Eigenständig:** jedes Skript läuft für sich; keine Cross-Imports zwischen Werkzeugen.
* **Konfigurationsgesteuert:** Ziele, Anmeldedaten und Pfade kommen aus Flags oder Umgebungsvariablen. Geheimnisse werden nur aus der Umgebung gelesen, niemals über die Befehlszeile übergeben.
* **`--dry-run`** für alles, was den Zustand verändert; **`--help`** überall.
* **Lokal-zuerst:** KI-/Datenwerkzeuge verwenden standardmäßig lokale Dienste (Ollama, SearXNG, eine lokale Vektor-DB usw.) und degradieren elegant, wenn ein Dienst nicht erreichbar ist.Search the yala toolkit's 500+ standalone CLI utilities by task (e.g. 'diff openapi specs', 'redis memory', 'gfs retention'). Returns ranked matches with descriptions. Start here.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Max results (default 8) | |
| query | Yes | What you want to do, in plain words | |
| category | No | Optional category slug filter |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavior. It states it returns ranked matches with descriptions, which gives the return format. However, it does not mention whether the operation is read-only, any authentication requirements, or potential errors. For a search tool, this is adequate but not highly transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise (two sentences) and front-loaded with the core action and examples. 'Start here' is a useful directive. No unnecessary words or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (3 params, no output schema), the description covers what it does, gives concrete examples, and specifies the return type (ranked matches with descriptions). The schema handles parameter details, so the description is complete for an agent to correctly invoke it.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with clear descriptions for each parameter (query, limit, category). The tool description adds no extra parameter information beyond the schema, but the schema already provides sufficient meaning. Baseline of 3 applies because the description does not need to compensate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: to search the yala toolkit's 500+ CLI utilities by task. It uses a specific verb ('search') and resource ('yala toolkit's 500+ standalone CLI utilities'), and includes examples. This distinguishes it from siblings like tool_info (specific tool details), run_tool (execution), and list_categories (category listing).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'Start here' clearly positions this as the entry point for finding tools, implying it should be used before other tools when you need to locate a utility. However, it does not explicitly state when not to use it or mention alternative tools, though the context provides enough guidance for an agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Overview of every yala toolkit category with tool counts.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no annotations, so the description carries the full burden of disclosing behavior. It implies a read-only operation by saying 'overview' but does not explicitly state that no modifications occur, nor does it mention any permissions, side effects, or return format. This is a minimal disclosure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that conveys the essential purpose with no filler. Every word adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple list tool with no output schema, the description adequately covers the main purpose and output scope. It could mention the format of the counts or categories, but for the low complexity, it is sufficiently complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, and the baseline for this case is 4. The description does not need to add parameter-specific information, as there is nothing to clarify.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool provides an overview of every yala toolkit category with tool counts. It uses a specific resource ('yala toolkit category') and identifies the output scope ('with tool counts'), making it distinct from siblings like find_tools or tool_info.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. It does not mention scenarios where find_tools or tool_info would be more appropriate, nor does it specify any prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Execute a yala tool from the toolkit root and return exit code, stdout, stderr, and timing. Args are an argv list (no shell). Tools marked mutates=true support --dry-run — prefer it first.
| Name | Required | Description | Default |
|---|---|---|---|
| args | No | Command-line arguments, one list element each | |
| name | Yes | ||
| stdin | No | Optional text piped to the tool | |
| timeout_s | No | Seconds before the run is killed (default 60, max 300) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It transparently discloses the return format (exit code, stdout, stderr, timing), the no-shell argument behavior, and the dry-run support for mutating tools. This is substantial for an execution tool, though it could mention error handling or permissions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, front-loaded with the primary purpose, and every sentence contributes useful information. No redundant phrases, and the dry-run tip is valuable without bloating the text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and no annotations, the description provides necessary return-value information (exit code, stdout, stderr, timing) and context (toolkit root, no shell). It covers the main execution aspects, though it could arguably mention what happens on timeout or failure, which is partially covered by timeout_s in the schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 75% (3/4 params described). The description adds meaning beyond the schema by clarifying that args are an argv list (no shell) and that --dry-run is a preferred flag for mutating tools, which contextualizes the args parameter. This adds value over the schema alone.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb (execute) and resource (a yala tool), and specifies what it returns (exit code, stdout, stderr, timing). This distinguishes it from sibling tools like find_tools and tool_info, which are for discovery rather than execution.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides a clear usage guideline: prefer --dry-run for tools with mutates=true. While it does not explicitly name alternatives, it is the only execution tool among siblings, and the dry-run guidance is directly actionable, implying when to use this tool for safe testing first.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Full detail for one yala tool: description, example commands, live --help, and whether it mutates state. Use before run_tool.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Tool filename or stem, e.g. openapi_diff.py |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations are absent, so the description carries the burden. It mentions 'live --help' and 'whether it mutates state', but does not explicitly state whether tool_info itself has side effects or is read-only. The instruction 'Use before run_tool' hints it's safe, but not explicitly confirmed, leaving some ambiguity.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences that list what the tool provides and when to use it. No unnecessary words or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description explains the return content (description, examples, help, mutation status) and the intended usage context. It is complete for a retrieval tool without needing error details.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Only one parameter 'name' with a clear description and example ('openapi_diff.py'). The schema covers 100% and the example enhances understanding, so it's above baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: to provide full detail about a single tool, including description, example commands, live --help, and mutation status. This distinguishes it from siblings like find_tools (discovery), run_tool (execution), and list_categories (categorization).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly says 'Use before run_tool', giving a clear directive on when to call this tool. It also implies it's for retrieving details about a specific tool, contrasting with find_tools for searching and list_categories for listing categories.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.1.0find_toolslist_categoriesrun_tooltool_infoScored across 4 tools
Each tool has a distinct purpose: find_tools searches for utilities, tool_info provides details on a specific tool, run_tool executes a tool, and list_categories gives an overview. No overlap or ambiguity.
All tool names follow a consistent lower_snake_case pattern with a clear verb or action prefix (find, tool_info, run, list). The naming is uniform and predictable.
With only 4 tools, the set is tightly scoped to the server's purpose of discovering, inspecting, and running CLI utilities. Each tool earns its place without redundancy.
The toolset covers the full workflow: discovering tools (find_tools, list_categories), getting details (tool_info), and executing them (run_tool). There are no missing operations for the stated purpose.
327 dev tools via REST API and MCP. Generate Dockerfiles, schemas, K8s, APIs, and more.
MCP server for your apps' tools and custom tools, plus hosted AI agents and approval-gated workflows
A MCP server built for developers enabling Git based project management with project and personal…
AI-native git hosting — repos, PRs, issues, CI gates, and AI code review over MCP (60 tools).
