Communitygithub.com

Lev-it/lev-skills

Ink-Terminal-Renderer für json-render, der JSON-Spezifikationen in interaktive Terminal-UIs verwandelt. Verwenden Sie dies, wenn Sie mit @json-render/ink arbeiten, Terminal-UIs aus JSON erstellen, Komponentenkataloge für das Terminal aufbauen oder KI-generierte Spezifikationen im Terminal rendern möchten.

Was ist lev-skills?

Diese Fertigkeit stellt `@json-render/ink` bereit, einen leistungsstarken Ink-Terminal-Renderer, der JSON-Spezifikationen in interaktive Terminal-Benutzeroberflächen umwandelt. Sie ermöglicht es Entwicklern, komplexe Terminal-UI-Komponentenbäume mit einer flachen Element-Map-Struktur zu definieren, die Komponenten wie Layout-Container (`Box`), Textelemente (`Text`), Inhaltskomponenten (`Heading`, `Divider`, `Badge`, `ProgressBar`, `Table`) und interaktive Elemente (`TextInput`, `Select`, `Tabs`) unterstützt. Der Renderer nutzt ein zustandsgesteuertes System mit Sichtbarkeitsbedingungen, dynamischen Prop-Ausdrücken (einschließlich bidirektionaler Datenbindung über `$bindState`), einem integrierten Aktionssystem (`setState`, `pushState`, `removeState`) und der Möglichkeit, Listen mit `repeat` dynamisch zu rendern. Die Fertigkeit ist plattformunabhängig und wird hauptsächlich mit Ink-Terminals (Node.js) verwendet; sie lässt sich nahtlos in KI-gesteuerte Workflows integrieren, um KI-generierte UI-Spezifikationen zu rendern, und bietet erweiterte APIs wie `createRenderer`, `useUIStream` für Streaming-Spezifikationen und Server-seitige Prompt-Generierung für KI-Integrationen.

Funktioniert mit~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/Lev-it/lev-skills/tree/HEAD/.claude/skills/ink

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

@json-render/ink

Ink-Terminal-Renderer, der JSON-Spezifikationen in interaktive Terminal-Komponentenbäume mit Standardkomponenten, Datenbindung, Sichtbarkeit, Aktionen und dynamischen Props umwandelt.

Kurzstart

import { defineCatalog } from "@json-render/core";
import { schema } from "@json-render/ink/schema";
import {
  standardComponentDefinitions,
  standardActionDefinitions,
} from "@json-render/ink/catalog";
import { defineRegistry, Renderer, type Components } from "@json-render/ink";
import { z } from "zod";

// Katalog mit Standard- und benutzerdefinierten Komponenten erstellen
const catalog = defineCatalog(schema, {
  components: {
    ...standardComponentDefinitions,
    CustomWidget: {
      props: z.object({ title: z.string() }),
      slots: [],
      description: "Benutzerdefiniertes Widget",
    },
  },
  actions: standardActionDefinitions,
});

// Nur benutzerdefinierte Komponenten registrieren (Standardkomponenten sind eingebaut)
const { registry } = defineRegistry(catalog, {
  components: {
    CustomWidget: ({ props }) => <Text>{props.title}</Text>,
  } as Components<typeof catalog>,
});

// Rendern
function App({ spec }) {
  return (
    <JSONUIProvider initialState={{}}>
      <Renderer spec={spec} registry={registry} />
    </JSONUIProvider>
  );
}

Spezifikationsstruktur (Flache Element-Map)

Das Ink-Schema verwendet eine flache Element-Map mit einem root-Schlüssel:

{
  "root": "main",
  "elements": {
    "main": {
      "type": "Box",
      "props": { "flexDirection": "column", "padding": 1 },
      "children": ["heading", "content"]
    },
    "heading": {
      "type": "Heading",
      "props": { "text": "Dashboard", "level": "h1" },
      "children": []
    },
    "content": {
      "type": "Text",
      "props": { "text": "Hallo vom Terminal!" },
      "children": []
    }
  }
}

Standardkomponenten

Layout

  • Box - Flexbox-Layoutcontainer (wie ein terminalbasiertes <div>). Zum Gruppieren, Abstandhalten, Rahmen und Ausrichten. Standardmäßig ist flexDirection row.
  • Text - Textausgabe mit optionalem Styling (Farbe, fett, kursiv usw.)
  • Newline - Fügt Leerzeilen ein. Muss sich innerhalb einer Box mit flexDirection column befinden.
  • Spacer - Flexibler leerer Raum, der sich entlang der Hauptachse ausdehnt.

Inhalt

  • Heading - Abschnittsüberschrift (h1: fett+unterstrichen, h2: fett, h3: fett+gedimmt, h4: gedimmt)
  • Divider - Horizontaler Trenner mit optionalem zentrierten Titel
  • Badge - Farbige Inline-Beschriftung (Varianten: default, info, success, warning, error)
  • Spinner - Animierter Ladespinner mit optionalem Label
  • ProgressBar - Horizontale Fortschrittsanzeige (0-1)
  • Sparkline - Inline-Diagramm mit Unicode-Blockzeichen
  • BarChart - Horizontales Balkendiagramm mit Beschriftungen und Werten
  • Table - Tabellarische Daten mit Kopf- und Zeilen
  • List - Aufzählungs- oder Nummerierte Liste
  • ListItem - Strukturierte Listenzeile mit Titel, Untertitel, vorangestelltem/nachgestelltem Text
  • Card - Umrandeter Container mit optionalem Titel
  • KeyValue - Schlüssel-Wert-Paar-Anzeige
  • Link - Klickbarer URL mit optionalem Label
  • StatusLine - Statusnachricht mit farbigem Symbol (info, success, warning, error)
  • Markdown - Rendert Markdown-Text mit Terminal-Styling

Interaktiv

  • TextInput - Texteingabefeld (Events: submit, change)
  • Select - Auswahlmenü mit Pfeiltastennavigation (Events: change)
  • MultiSelect - Mehrfachauswahl mit Leertaste zum Umschalten (Events: change, submit)
  • ConfirmInput - Ja/Nein-Bestätigungsaufforderung (Events: confirm, deny)
  • Tabs - Registerkartennavigation mit linken/rechten Pfeiltasten (Events: change)

Sichtbarkeitsbedingungen

Verwenden Sie visible an Elementen, um sie basierend auf dem Zustand ein-/auszublenden. Syntax: { "$state": "/pfad" }, { "$state": "/pfad", "eq": wert }, { "$state": "/pfad", "not": true }, { "$and": [bedingung1, bedingung2] } für UND, { "$or": [bedingung1, bedingung2] } für ODER.

Dynamische Prop-Ausdrücke

Jeder Prop-Wert kann ein datengesteuerter Ausdruck sein, der zur Renderzeit aufgelöst wird:

  • { "$state": "/state/key" } - liest aus dem Zustandsmodell (nur Lesen)
  • { "$bindState": "/pfad" } - bidirektionale Bindung: für das natürliche Wert-Prop von Formularkomponenten verwenden
  • { "$bindItem": "feld" } - bidirektionale Bindung an ein Wiederholungselement-Feld
  • { "$cond": <bedingung>, "$then": <wert>, "$else": <wert> } - bedingter Wert
  • { "$template": "Hallo, ${/name}!" } - interpoliert Zustandswerte in Zeichenketten

Komponenten verwenden kein statePath-Prop für bidirektionale Bindung. Verwenden Sie stattdessen { "$bindState": "/pfad" } am natürlichen Wert-Prop.

Event-System

Komponenten verwenden emit, um benannte Events auszulösen. Das on-Feld eines Elements ordnet Events Aktionsbindungen zu:

CustomButton: ({ props, emit }) => (
  <Box>
    <Text>{props.label}</Text>
    {/* emit("press") löst die im on.press der Spezifikation gebundene Aktion aus */}
  </Box>
),
{
  "type": "CustomButton",
  "props": { "label": "Senden" },
  "on": { "press": { "action": "submit" } },
  "children": []
}

Eingebaute Aktionen

setState, pushState und removeState sind eingebaut und werden automatisch behandelt:

{ "action": "setState", "params": { "statePath": "/activeTab", "value": "home" } }
{ "action": "pushState", "params": { "statePath": "/items", "value": { "text": "Neu" } } }
{ "action": "removeState", "params": { "statePath": "/items", "index": 0 } }

Repeat (Dynamische Listen)

Verwenden Sie das repeat-Feld an einem Containerelement, um Elemente aus einem Zustandsarray zu rendern:

{
  "type": "Box",
  "props": { "flexDirection": "column" },
  "repeat": { "statePath": "/items", "key": "id" },
  "children": ["item-row"]
}

Innerhalb wiederholter Kinder verwenden Sie { "$item": "field" }, um aus dem aktuellen Element zu lesen, und { "$index": true } für den aktuellen Index.

Streaming

Verwenden Sie useUIStream, um Spezifikationen schrittweise aus JSONL-Patch-Streams zu rendern:

import { useUIStream } from "@json-render/ink";

const { spec, send, isStreaming } = useUIStream({ api: "/api/generate" });

Serverseitige Prompt-Generierung

Verwenden Sie den Export ./server, um KI-System-Prompts aus Ihrem Katalog zu generieren:

import { catalog } from "./catalog";

const systemPrompt = catalog.prompt({ system: "Sie sind ein Terminal-Assistent." });

Provider

ProviderZweck
StateProviderZustand zwischen Komponenten teilen (JSON-Pointer-Pfade). Akzeptiert optionales store-Prop für kontrollierten Modus.
ActionProviderAktionen behandeln, die über das Event-System ausgelöst werden
VisibilityProviderBedingte Darstellung basierend auf dem Zustand ermöglichen
ValidationProviderFormularfeld-Validierung
FocusProviderFokus über interaktive Komponenten hinweg verwalten
JSONUIProviderKombinierter Provider für alle Kontexte

Externer Store (Kontrollierter Modus)

Übergeben Sie einen StateStore an StateProvider (oder JSONUIProvider), um eine externe Zustandsverwaltung zu verwenden:

import { createStateStore, type StateStore } from "@json-render/ink";

const store = createStateStore({ count: 0 });

<StateProvider store={store}>{children}</StateProvider>

store.set("/count", 1); // React rendert automatisch neu

Wenn store angegeben wird, werden initialState und onStateChange ignoriert.

createRenderer (Höhere API-Ebene)

import { createRenderer } from "@json-render/ink";
import { standardComponents } from "@json-render/ink";
import { catalog } from "./catalog";

const InkRenderer = createRenderer(catalog, {
  ...standardComponents,
  // benutzerdefinierte Komponenten-Überschreibungen hier
});

// InkRenderer enthält alle Provider (Zustand, Sichtbarkeit, Aktionen, Fokus)
render(
  <InkRenderer spec={spec} state={{ activeTab: "overview" }} />
);

Wichtige Exporte

ExportZweck
defineRegistryTypsicheres Komponentenregister aus einem Katalog erstellen
RendererEine Spezifikation mithilfe eines Registers rendern
createRendererHöhere Ebene: erstellt eine Komponente mit integrierten Providern
JSONUIProviderKombinierter Provider für alle Kontexte
schemaInk-Flache-Element-Map-Schema (enthält eingebaute Zustandsaktionen)
standardComponentDefinitionsKatalogdefinitionen für alle Standardkomponenten
standardActionDefinitionsKatalogdefinitionen für Standardaktionen
standardComponentsVorgefertigte Komponentenimplementierungen
useStateStoreZugriff auf den Zustandskontext
useStateValueEinzelnen Wert aus dem Zustand abrufen
useBoundPropBidirektionale Bindung für $bindState/$bindItem-Ausdrücke
useActionsZugriff auf den Aktionskontext
useActionEinzelne Aktions-Dispatch-Funktion abrufen
useOptionalValidationNicht-werfende Variante von useValidation
useUIStreamSpezifikationen von einem API-Endpunkt streamen
createStateStoreFramework-agnostischen In-Memory-StateStore erstellen
StateStoreSchnittstelle zur Anbindung externer Zustandsverwaltung
ComponentsTypisierte Komponenten-Map (katalogbewusst)
ActionsTypisierte Aktions-Map (katalogbewusst)
ComponentContextTypisierter Komponentenkontext (katalogbewusst)
flatToTreeFlache Element-Map in eine Baumstruktur umwandeln

Gestaltungsrichtlinien für Terminal-UI

  • Verwenden Sie Box für das Layout (flexDirection, padding, gap). Standardmäßig ist flexDirection row.
  • Die Terminalbreite beträgt ~80-120 Spalten. Bevorzugen Sie vertikale Layouts (flexDirection: column) für die Hauptstruktur.
  • Verwenden Sie borderStyle an Box für visuelle Gruppierung (single, double, round, bold).
  • Verwenden Sie benannte Terminalfarben: red, green, yellow, blue, magenta, cyan, white, gray.
  • Verwenden Sie Heading für Abschnittstitel, Divider zum Trennen von Abschnitten, Badge für den Status, KeyValue für beschriftete Daten, Card für umrandete Gruppen.
  • Verwenden Sie Tabs für Multi-View-UI mit sichtbaren Bedingungen auf dem untergeordneten Inhalt.
  • Verwenden Sie Sparkline für Inline-Trends und BarChart zum Vergleichen von Werten.

Individual skills in this repo

This repo contains 11 individual skills — each has its own dedicated page.

Lev-it/lev-skills

Ask which skill or flow fits your situation. A router over the user-invoked skills in this repo.

Lev-it/lev-skills

Premium brand-kit image generation skill for creating high-end brand-guidelines boards, logo systems, identity decks, and visual-world presentations. Trained for minimalist, cinematic, editorial, dark-tech, luxury, cultural, security, gaming, developer-tool, and consumer-app brand systems. Optimized for intentional logo concepting, refined composition, sparse typography, strong symbolic meaning, premium mockups, art-directed imagery, and flexible grid layouts.

Lev-it/lev-skills

Compact the current conversation into a handoff document for another agent to pick up.

Lev-it/lev-skills

Interactive QA session where user reports bugs or issues conversationally, and the agent files GitHub issues. Explores the codebase in the background for context and domain language. Use when user wants to report bugs, do QA, file issues conversationally, or mentions "QA session".

Lev-it/lev-skills

Facilitate a structured sprint retrospective — what went well, what didn't, and prioritized action items with owners and deadlines. Use when running a retrospective, reflecting on a sprint, creating action items from team feedback, or learning how to run effective retros.

Lev-it/lev-skills

Review the changes since a fixed point (commit, branch, tag, or merge-base) along two axes — Standards (does the code follow this repo's documented coding standards?) and Spec (does the code match what the originating issue/PRD asked for?). Runs both reviews in parallel sub-agents and reports them side by side. Use when the user wants to review a branch, a PR, work-in-progress changes, or asks to "review since X".

Lev-it/lev-skills

Test-driven development. Use when the user wants to build features or fix bugs test-first, mentions "red-green-refactor", or wants integration tests.

Lev-it/lev-skills

Teach the user a new skill or concept, within this workspace.

Lev-it/lev-skills

Turn the current conversation into a PRD and publish it to the project issue tracker — no interview, just synthesis of what you've already discussed.

Lev-it/lev-skills

Move issues through a state machine of triage roles — categorise, reproduce, grill if needed, and write agent-ready briefs.

Lev-it/lev-skills

Create product backlog items in Why-What-Acceptance format — independent, valuable, testable items with strategic context. Use when writing structured backlog items, breaking features into work items, or using the WWA format.

Verwandte Skills