sema-claude v2.0 — Semantic Search + Fabric AI Pipeline

Was macht dieses Tool?

sema-claude ist eine Zsh-Shell-Funktion, die drei Werkzeuge zu einer interaktiven Pipeline verbindet:

Beispiel: Du tippst sema-claude "Wardley Maps". sema findet 20 Dateien. Du wählst 3 davon aus. Dann wählst du extract_wisdom. Claude Code liest alle 3 Dateien und extrahiert Ideen, Zitate, Erkenntnisse — alles auf Deutsch.

Pipeline-Übersicht

flowchart TD
    A["Suchbegriff eingeben<br/><i>z.B. 'Wardley Maps'</i>"] --> B["sema CLI<br/>Semantische Suche"]
    B --> C["fzf Dateiauswahl<br/>Tab = markieren, Enter = fertig"]
    C --> D{"Welcher Modus?"}
    D -->|"Kuratiertes Pattern"| E["Fabric Pattern waehlen<br/><i>28 Patterns in 7 Kategorien</i>"]
    D -->|"Freie Frage"| F["Eigene Frage eingeben"]
    D -->|"Alle durchsuchen"| G["Alle 239 Patterns<br/>mit fzf durchsuchen"]
    E --> H["system.md laden<br/><i>~/.config/fabric/patterns/</i>"]
    G --> H
    F --> I["Prompt zusammenbauen"]
    H --> I
    I --> J["Claude Code<br/>Dateien lesen + Framework abarbeiten"]
    J --> K["Ausgabe auf Deutsch"]
            

Voraussetzungen

Komponentenarchitektur

graph TB
    subgraph Terminal["Terminal (Zsh)"]
        SC["sema-claude()<br/><i>Shell-Funktion</i>"]
    end
    subgraph SemaSystem["sema System"]
        CLI["sema CLI<br/>bun cli.ts"]
        DB["sema.db<br/><i>sqlite-vec</i><br/>38.425 Chunks"]
        EMB["HuggingFace<br/>Embeddings"]
        CLI --> DB
        DB --> EMB
    end
    subgraph FabricSystem["Fabric AI"]
        PDIR["~/.config/fabric/patterns/"]
        P1["extract_wisdom/<br/>system.md"]
        P2["summarize/<br/>system.md"]
        P3["... 237 weitere ..."]
        PDIR --> P1
        PDIR --> P2
        PDIR --> P3
    end
    subgraph Tools["Interaktive Tools"]
        FZF["fzf<br/><i>Fuzzy Finder</i>"]
    end
    subgraph Claude["Claude Code"]
        CC["claude CLI<br/><i>Anthropic API</i>"]
    end
    SC --> CLI
    SC --> FZF
    SC --> PDIR
    SC --> CC
            

5 Komponenten werden benötigt

Datenfluss

flowchart LR
    subgraph Stufe1["Stufe 1: Semantische Suche"]
        Q["query<br/>'Wardley Maps'"] --> SEMA["sema CLI"]
        SEMA --> RAW["raw_output<br/>1. [0.712] /pfad/datei.md<br/>2. [0.823] /pfad/andere.md"]
        RAW --> SED["sed Parser"]
        SED --> LINES["file_lines<br/>[0.712] /pfad/datei.md<br/>[0.823] /pfad/andere.md"]
    end
    subgraph Stufe1b["Stufe 1b: Dateiauswahl"]
        LINES --> FZF1["fzf --multi"]
        FZF1 --> SELECTED["selected<br/>[0.712] /pfad/datei.md"]
        SELECTED --> SED2["sed Score entfernen"]
        SED2 --> PATHS["paths<br/>/pfad/datei.md"]
    end
    subgraph Stufe2["Stufe 2: Pattern + Prompt"]
        PATHS --> LIST["file_list<br/>- /pfad/datei.md"]
        PATTERN["system.md<br/><i>Fabric Pattern</i>"] --> PROMPT["prompt"]
        LIST --> PROMPT
    end
    PROMPT --> CLAUDE["claude '$prompt'"]
            

Was ist fzf?

fzf (fuzzy finder) ist ein interaktiver Kommandozeilen-Filter. Stell dir vor, du hast eine lange Liste — z.B. 20 Suchergebnisse — und willst schnell die richtigen auswählen. fzf zeigt dir die Liste im Terminal, du tippst ein paar Buchstaben und die Liste filtert sich in Echtzeit.

Wichtige fzf-Parameter

Shell-Grundlagen (für Anfänger)

Wenn du noch nie ein Shell-Script geschrieben hast, erklärt dieser Abschnitt alle Konzepte, die im sema-claude-Code vorkommen. Jedes Konzept wird mit einem eigenen Beispiel gezeigt.

Variablen

Eine Variable speichert einen Wert. In Zsh schreibst du den Namen ohne Leerzeichen um das =:

# Einfache Variable
name="Holger"
echo "$name"     # Gibt: Holger

# Lokale Variable (nur in der Funktion sichtbar)
local query="Wardley Maps"

# Lokales Array
local -a SEMA_CLI=(bun /pfad/cli.ts)

Funktions-Definition

Eine Funktion ist ein wiederverwendbarer Codeblock mit einem Namen:

# Funktion definieren
sema-claude() {
    echo "Hallo von sema-claude"
    # ... hier kommt der Code
}

# Funktion aufrufen
sema-claude

Der Code zwischen { und } wird erst ausgeführt, wenn du den Funktionsnamen tippst. Die Klammern () nach dem Namen sind Pflicht — sie sagen der Shell: „Das ist eine Funktion.“

Parameter und Argumente

Wenn du einer Funktion Werte mitgibst, landen sie in $1, $2, etc.:

greet() {
    echo "Hallo, $1!"     # $1 = erstes Argument
}

greet "Welt"               # Gibt: Hallo, Welt!
greet "Claude"             # Gibt: Hallo, Claude!

${1:-} ist ein sicherer Zugriff: Wenn $1 leer ist, wird ein leerer String zurückgegeben statt eines Fehlers. Variante mit Default-Wert:

local query="${1:-}"           # Leer, wenn nichts uebergeben
local top="${2:-20}"           # Default: 20, wenn $2 fehlt

Bedingte Ausführung

Die doppelten eckigen Klammern [[ ]] prüfen Bedingungen:

# -z = "ist leer?" (zero length)
[[ -z "$query" ]]      # wahr, wenn $query leer ist

# -n = "ist NICHT leer?" (non-zero)
[[ -n "$query" ]]      # wahr, wenn $query einen Wert hat

# -f = "existiert die Datei?"
[[ -f "$pattern_file" ]]  # wahr, wenn Datei existiert

# Vergleiche
[[ "$name" == "Holger" ]]  # String-Vergleich
[[ "$count" -gt 10 ]]     # Zahl groesser als 10

if / then / fi

Die klassische Verzweigung:

if [[ -z "$query" ]]; then
    echo "Kein Suchbegriff!"
    return 1
fi

# Mit else:
if [[ -f "$file" ]]; then
    echo "Datei gefunden"
else
    echo "Datei nicht vorhanden"
fi

Kurzform mit &&

&& bedeutet „UND — führe den rechten Befehl nur aus, wenn der linke erfolgreich war“:

# Kurzform statt if/then/fi:
[[ -z "$selected" ]] && { echo "Abgebrochen."; return 1; }

# Das ist identisch mit:
if [[ -z "$selected" ]]; then
    echo "Abgebrochen."
    return 1
fi

Die geschweiften Klammern { } gruppieren mehrere Befehle. Wichtig: Das Semikolon vor } ist Pflicht!

Kurzform mit $DEBUG

local DEBUG=false

# $DEBUG wird "ausgefuehrt" - false ist ein gueltiger Befehl (gibt immer Fehler)
# && fuehrt printf nur aus, wenn $DEBUG=true
$DEBUG && printf "[DEBUG] Wert: %s\n" "$var"

# Aequivalent zu:
if $DEBUG; then
    printf "[DEBUG] Wert: %s\n" "$var"
fi

Command Substitution $( )

Fängt die Ausgabe eines Befehls in einer Variable auf:

# Die Ausgabe von sema CLI wird in raw_output gespeichert
local raw_output
raw_output=$("${SEMA_CLI[@]}" search "$query" --top "$TOP" 2>&1)

# Einfacheres Beispiel:
local today=$(date +%Y-%m-%d)   # z.B. "2026-02-18"
local files=$(ls *.md)          # Alle .md-Dateien

Alles zwischen $( und ) wird ausgeführt und das Ergebnis ersetzt den gesamten Ausdruck.

Arrays mit [@]

# Array definieren
local -a SEMA_CLI=(bun /pfad/cli.ts)

# Alle Elemente des Arrays einsetzen
"${SEMA_CLI[@]}"
# wird zu: bun /pfad/cli.ts

# Warum Array statt String?
local SEMA_CLI_STRING="bun /pfad/cli.ts"
$SEMA_CLI_STRING     # PROBLEM: Zsh zerlegt am Leerzeichen falsch

# Mit Array:
"${SEMA_CLI[@]}"     # KORREKT: Jedes Element wird einzeln uebergeben

Pipe |

Die Pipe leitet die Ausgabe eines Befehls als Eingabe an den nächsten:

# Ausgabe von echo geht an sed:
echo "Hallo Welt" | sed 's/Welt/Claude/'
# Ergebnis: Hallo Claude

# Mehrere Pipes hintereinander:
echo "$raw_output" | sed -n 's/^pattern/\1/p' | wc -l | tr -d ' '
#    Ausgabe      → parsen         → Zeilen zaehlen → Leerzeichen weg

Jeder | nimmt die Standardausgabe (stdout) des linken Befehls und füttert sie als Standardeingabe (stdin) in den rechten.

sed (Stream Editor)

sed verarbeitet Text zeilenweise mit Regulären Ausdrücken. Zentral für sema-claude, weil wir damit die sema-Ausgabe parsen:

# Der wichtigste sed-Befehl im Script:
sed -n 's/^[[:space:]]*[0-9]*\.[[:space:]]*\(\[.*\]\)/\1/p'

Das sieht auf den ersten Blick verwirrend aus. Zerlegen wir es:

Vorher → Nachher:

# Eingabe (sema-Ausgabe):
"  1.  [0.712] /pfad/wardley-maps.md"
"  2.  [0.823] /pfad/strategie-als-hypothese.md"

# Nach sed:
"[0.712] /pfad/wardley-maps.md"
"[0.823] /pfad/strategie-als-hypothese.md"

Ein zweiter, einfacherer sed-Befehl entfernt später den Score:

sed 's/^\[.*\] //'
# Vorher: [0.712] /pfad/wardley-maps.md
# Nachher: /pfad/wardley-maps.md

awk

awk ist ein Textverarbeitungs-Tool, das Zeilen in Spalten zerlegt:

# Erste Spalte extrahieren (Trennzeichen: Leerzeichen)
echo "extract_wisdom  │ Weisheit extrahieren" | awk '{print $1}'
# Ergebnis: extract_wisdom

# Im Script: Pattern-Name aus der fzf-Auswahl extrahieren
local pattern
pattern=$(echo "$choice" | awk '{print $1}')

$1 bei awk bedeutet „erste Spalte“, $2 die zweite, etc. Standardmäßig trennt awk an Leerzeichen.

printf

printf gibt formatierten Text aus — zuverlässiger als echo:

# Formatierter Text mit Platzhaltern
printf "Suche nach \"%s\" ...\n" "$query"
# Gibt: Suche nach "Wardley Maps" ...

# Farbige Ausgabe mit ANSI-Codes
printf "\033[1;36m🔍 Semantic Search\033[0m\n"
printf "\033[0;33m⏳ Suche ...\033[0m\n"
printf "\033[0;32m✅ %s Treffer\033[0m\n" "$count"

ANSI-Farbcodes

Das Format: \033[ startet eine Escape-Sequenz, die Zahl bestimmt die Farbe, m beendet sie.

read (Benutzereingabe)

# Eingabe vom Benutzer lesen
printf "Suchbegriff: "
read -r query

# -r = "raw mode" - verhindert, dass Backslash als Escape interpretiert wird
# $query enthaelt jetzt die Eingabe

Im Script wird read -r an drei Stellen verwendet:

1. Suchbegriff abfragen (wenn keiner als Argument übergeben)
2. Freie Frage eingeben (bei FREIE_FRAGE Pattern)
3. Bestätigung vor dem Start (Enter drücken)

Here-String <<<

# Here-String: Text als stdin uebergeben
while IFS= read -r p; do
    file_list+="- $p"$'\n'
done <<< "$paths"

# <<< "$paths" fuettert den Inhalt von $paths Zeile fuer Zeile
# in die while-Schleife

2>&1 (stderr umleiten)

# Normalerweise gibt es zwei Ausgabe-Kanaele:
# 1 = stdout (normale Ausgabe)
# 2 = stderr (Fehlermeldungen)

# 2>&1 bedeutet: stderr (2) nach stdout (1) umleiten
raw_output=$("${SEMA_CLI[@]}" search "$query" --top "$TOP" 2>&1)

# Ohne 2>&1: Fehlermeldungen erscheinen im Terminal statt in der Variable
# Mit 2>&1:  ALLES landet in $raw_output

Wichtig für sema-claude, weil manche CLI-Tools Warnungen auf stderr schreiben, die sonst verloren gehen.

$? (Exit-Code)

# Jeder Befehl gibt einen Exit-Code zurueck:
# 0 = Erfolg
# 1-255 = Fehler

ls /existiert/nicht
echo $?    # Gibt: 1 (Fehler)

ls /tmp
echo $?    # Gibt: 0 (Erfolg)

# Im Script:
local exit_code=$?
# Speichert den Exit-Code des vorherigen Befehls

String-Länge und Substring

# Laenge eines Strings:
echo ${#prompt}          # z.B. 2847 (Zeichen)

# Substring (erste 300 Zeichen):
echo "${prompt:0:300}"   # Ab Position 0, 300 Zeichen

# Letzte 150 Zeichen:
echo "${prompt: -150}"   # Leerzeichen vor dem Minus ist Pflicht!

# Im Script: Langen Prompt abkuerzen
if [[ ${#prompt} -gt 500 ]]; then
    echo "${prompt:0:300}"
    printf "\n... (%s Zeichen) ...\n" "${#prompt}"
    echo "${prompt: -150}"
fi

wc -l | tr -d ' '

# wc -l = Zeilen zaehlen (word count, lines)
echo "$file_lines" | wc -l
# Gibt z.B.: "      20" (mit fuehrenden Leerzeichen!)

# tr -d ' ' = Leerzeichen loeschen (translate, delete)
echo "$file_lines" | wc -l | tr -d ' '
# Gibt: "20" (sauber)

# Im Script:
local count=$(echo "$file_lines" | wc -l | tr -d ' ')

cat (Datei lesen)

# cat gibt den Inhalt einer Datei aus:
cat system.md

# Im Script: Pattern-Datei einlesen
local system_prompt
system_prompt=$(cat "$pattern_file")
# $system_prompt enthaelt jetzt den gesamten Dateiinhalt

cat steht für „concatenate“ (verknüpfen) und kann auch mehrere Dateien zusammenfügen: cat file1.txt file2.txt.

Installation

Schritt 1: Datei anlegen

mkdir -p ~/.zsh/functions
# Kopiere den Code (siehe Anhang) in diese Datei:
# ~/.zsh/functions/sema-claude.zsh

Schritt 2: In .zshrc laden

Füge diese Zeile am Ende deiner ~/.zshrc hinzu:

source ~/.zsh/functions/sema-claude.zsh

Schritt 3: Pfade anpassen

In der Datei sema-claude.zsh, passe diese zwei Variablen an:

# Pfad zu deiner sema CLI (Zeile 11):
local -a SEMA_CLI=(bun /dein/pfad/zu/sema/cli.ts)

# Pfad zu deinen Fabric Patterns (Zeile 14):
local PATTERNS_DIR="$HOME/.config/fabric/patterns"

Schritt 4: Shell neu laden und testen

source ~/.zshrc

# Test:
sema-claude "suchbegriff"

# Mit Debug-Ausgabe:
sema-claude --debug "suchbegriff"

Der Code Block für Block erklärt

Die Funktion besteht aus 13 logischen Blöcken. Jeder Block wird hier einzeln erklärt.

sema-claude() {
  local -a SEMA_CLI=(bun /Users/holgergelhausen/PAI/PAI_DIRECTORY/tools/sema/cli.ts)
  local TOP=20
  local DEBUG=false
  local PATTERNS_DIR="$HOME/.config/fabric/patterns"
  [[ "$1" == "--debug" ]] && { DEBUG=true; shift; }

  local query="${1:-}"
  if [[ -z "$query" ]]; then
    printf "\033[1;36m🔍 Semantic Search → Claude Code (Fabric AI)\033[0m\n"
    printf "Suchbegriff: "
    read -r query
    [[ -z "$query" ]] && { echo "Abgebrochen."; return 1; }
  fi

  printf "\033[0;33m⏳ Suche nach \"%s\" ...\033[0m\n" "$query"
  local raw_output
  raw_output=$("${SEMA_CLI[@]}" search "$query" --top "$TOP" 2>&1)
  local exit_code=$?

  $DEBUG && printf "[DEBUG] exit_code=%s, output_length=%s\n" "$exit_code" "${#raw_output}"
  $DEBUG && echo "[DEBUG] First 3 lines:" && echo "$raw_output" | head -3

  if [[ -z "$raw_output" ]] || [[ ${#raw_output} -lt 10 ]]; then
    echo "❌ Keine Ausgabe von sema CLI (exit: $exit_code)"
    return 1
  fi

  local file_lines
  file_lines=$(echo "$raw_output" | sed -n 's/^[[:space:]]*[0-9]*\.[[:space:]]*\(\[.*\]\)/\1/p')

  if [[ -z "$file_lines" ]]; then
    echo "❌ Konnte Ergebnisse nicht parsen."
    return 1
  fi

  local count=$(echo "$file_lines" | wc -l | tr -d ' ')
  printf "\033[0;32m✅ %s Treffer\033[0m\n\n" "$count"

  local selected
  selected=$(echo "$file_lines" | fzf \
    --multi \
    --prompt="Tab=markieren, Enter=fertig > " \
    --header="🔍 \"$query\" — $count Treffer" \
    --preview='f=$(echo {} | sed "s/^\[.*\] //"); head -40 "$f" 2>/dev/null || echo "Keine Preview"' \
    --preview-window=right:50%:wrap \
    --height=80% \
    --border=rounded)

  local paths
  paths=$(echo "$selected" | sed 's/^\[.*\] //')
  local selected_count=$(echo "$paths" | wc -l | tr -d ' ')
  printf "\n\033[0;32m📄 %s Datei(en) gewählt\033[0m\n\n" "$selected_count"

  local -a CURATED=(
    "── ANALYSIEREN & ERKLÄREN ───│"
    "extract_wisdom               │ Weisheit, Ideen, Zitate, Gewohnheiten extrahieren"
    "extract_insights             │ Die 10 überraschendsten Kernerkenntnisse"
    ...
    "── CUSTOM ──────────────────-│"
    "FREIE_FRAGE                  │ Eigene Frage an Claude Code"
    "ALLE_PATTERNS                │ Alle 239 Fabric Patterns durchsuchen"
  )

  local choice
  choice=$(printf '%s\n' "${CURATED[@]}" | fzf \
    --prompt="Pattern wählen > " \
    --header="🧠 Fabric AI Pattern für Claude Code" \
    --preview='p=$(echo {} | awk "{print \$1}");
              f="'"$PATTERNS_DIR"'/$p/system.md";
              if [[ -f "$f" ]]; then
                printf "\033[1;33m── %s ──\033[0m\n\n" "$p"
                head -30 "$f"
              else
                echo "📂 Kategorie-Header"
              fi' \
    --preview-window=right:50%:wrap \
    --height=80% \
    --border=rounded \
    --no-multi)

  local pattern
  pattern=$(echo "$choice" | awk '{print $1}')

  if [[ "$pattern" == "──" ]]; then
    echo "⚠️ Kategorie-Header, kein Pattern."
    return 1
  fi

  local action=""
  if [[ "$pattern" == "FREIE_FRAGE" ]]; then
    printf "\033[1;36mDeine Frage:\033[0m "
    read -r action
    [[ -z "$action" ]] && { echo "Abgebrochen."; return 1; }
  fi

  if [[ "$pattern" == "ALLE_PATTERNS" ]]; then
    pattern=$(ls "$PATTERNS_DIR" | fzf \
      --prompt="Pattern suchen > " \
      --header="🔍 Alle Fabric Patterns durchsuchen" \
      --preview='f="'"$PATTERNS_DIR"'/{}/system.md";
                if [[ -f "$f" ]]; then
                  printf "\033[1;33m── {} ──\033[0m\n\n"
                  head -30 "$f"
                else
                  echo "Keine system.md gefunden"
                fi' \
      --preview-window=right:50%:wrap \
      --height=80% \
      --border=rounded \
      --no-multi)
    [[ -z "$pattern" ]] && { echo "Abgebrochen."; return 1; }
  fi

  local file_list=""
  while IFS= read -r p; do
    file_list+="- $p"$'\n'
  done <<< "$paths"

  local prompt=""

  if [[ -n "$action" ]]; then
    # Freie Frage: Einfacher Prompt
    prompt="$action

Basierend auf diesen Dateien (semantische Suche: \"$query\"):

$file_list
Lies bitte zuerst alle Dateien und arbeite dann die Aufgabe ab. Antworte auf Deutsch."
  else
    # Fabric Pattern: system.md laden
    local pattern_file="$PATTERNS_DIR/$pattern/system.md"
    if [[ ! -f "$pattern_file" ]]; then
      echo "❌ Pattern-Datei nicht gefunden: $pattern_file"
      return 1
    fi

    local system_prompt
    system_prompt=$(cat "$pattern_file")

    prompt="SPRACHE: Deine gesamte Ausgabe MUSS auf Deutsch sein. ...

Du folgst diesem Analyse-Framework:

---
$system_prompt
---

Wende dieses Framework auf folgende Dateien an (semantische Suche: \"$query\"):

$file_list
Lies bitte zuerst alle Dateien vollstaendig und arbeite dann das Framework systematisch auf Deutsch ab."
  fi

  printf "\n\033[1;36m━━━ Claude Code Prompt ━━━\033[0m\n"
  if [[ -n "$action" ]]; then
    printf "\033[0;33mModus:\033[0m Freie Frage\n"
    printf "\033[0;33mFrage:\033[0m %s\n" "$action"
  else
    printf "\033[0;33mPattern:\033[0m %s\n" "$pattern"
    printf "\033[0;33mQuelle:\033[0m %s\n" "$PATTERNS_DIR/$pattern/system.md"
  fi
  printf "\033[0;33mDateien:\033[0m %s\n" "$selected_count"
  printf "\033[0;33mSuche:\033[0m \"%s\"\n" "$query"
  printf "\033[1;36m━━━━━━━━━━━━━━━━━━━━━━━━━\033[0m\n\n"

  if [[ ${#prompt} -gt 500 ]]; then
    echo "${prompt:0:300}"
    printf "\n\033[0;90m... (%s Zeichen, inkl. system.md) ...\033[0m\n\n" "${#prompt}"
    echo "${prompt: -150}"
  else
    echo "$prompt"
  fi

  printf "\n\033[1;32mEnter\033[0m = Starten, \033[1;31mCtrl+C\033[0m = Abbrechen "
  read -r

  printf "\n\033[0;33m🚀 Starte Claude Code mit Fabric Pattern \"%s\"...\033[0m\n" "${pattern:-custom}"
  claude "$prompt"
}

Alle 28 kuratierten Patterns

Die 28 handverlesenen Fabric Patterns sind in 7 Kategorien organisiert. Jedes Pattern hat eine system.md-Datei mit einem präzisen Analyse-Framework.

Analysieren & Erklären (11 Patterns)

Zusammenfassen (4 Patterns)

Vergleichen (1 Pattern)

Content Erstellen (6 Patterns)

Extrahieren (4 Patterns)

Lernen (2 Patterns)

Fehlerbehebung

Claude Code Skill: obsidian-vault-query

Neben der Shell-Funktion sema-claude gibt es einen zweiten Weg, sema zu nutzen: als Claude Code Skill. Dieser Skill wird innerhalb von Claude Code aktiviert, nicht im Terminal.

Was ist ein Claude Code Skill?

Ein Skill ist eine SKILL.md-Datei im Verzeichnis .claude/skills/. Sie enthält Anweisungen, die Claude Code automatisch befolgt, wenn bestimmte Trigger-Wörter erkannt werden. Der Skill obsidian-vault-query bringt Claude Code bei, sema direkt aufzurufen.

Skill-Dateien und Pfade

Trigger-Wörter

Der Skill wird automatisch aktiviert, wenn du in Claude Code sagst:

• „Was haben wir zu...“
• „Finde alles über...“
• „sema search...“
• „Durchsuche den Vault nach...“
• „Welche Notizen gibt es zu...“

Verfügbare Befehle

Score-Logik

Workflow

1. Du fragst Claude Code: „Was haben wir zu Wardley Maps?“
2. Claude erkennt den Trigger und ruft sema search "Wardley Maps" auf
3. sema liefert Ergebnisse mit Scores und Pfaden
4. Claude liest die relevantesten Dateien und fasst zusammen

Shell-Funktion vs. Claude Code Skill

flowchart TD
    USER["Du"] --> CHOICE{"Wie willst du<br/>sema nutzen?"}
    CHOICE -->|"Interaktiv im Terminal<br/>mit Dateiauswahl + Fabric"| SHELL["sema-claude<br/><i>Shell-Funktion</i>"]
    CHOICE -->|"Direkt in Claude Code<br/>per Sprache"| SKILL["obsidian-vault-query<br/><i>Claude Code Skill</i>"]
    SHELL --> FZF["fzf: Dateien waehlen"]
    FZF --> FABRIC["Fabric Pattern waehlen"]
    FABRIC --> CLAUDE1["Claude Code<br/>mit vollem Prompt"]
    SKILL --> TRIGGER["Trigger: 'was haben wir zu...'"]
    TRIGGER --> SEMA2["Claude ruft sema CLI auf"]
    SEMA2 --> CLAUDE2["Claude zeigt Ergebnisse<br/>+ analysiert direkt"]
            

Anhang: Vollständiger Quellcode

Der komplette Quellcode der sema-claude-Funktion (Version 2.0.0, 251 Zeilen).

# sema-claude - Semantic Search → Claude Code Pipeline (Fabric-Powered)
# Version: 2.0.0
# Changelog:
#   v2.0.0 (18.02.2026) - Fabric AI Patterns statt simple Aktionen, 28 kuratierte Patterns in 7 Kategorien, system.md als Claude-Prompt
#   v1.3.0 (18.02.2026) - Fix: SEMA_CLI als Array statt String (zsh word-splitting)
#   v1.2.0 (18.02.2026) - Debug-Modus, stderr→stdout, robustere Erkennung
#   v1.1.0 (18.02.2026) - Fix: robusteres Parsing, bessere Preview
#   v1.0.0 (18.02.2026) - Initial: 2-stufiger Workflow sema → fzf → claude

sema-claude() {
  local -a SEMA_CLI=(bun /Users/holgergelhausen/PAI/PAI_DIRECTORY/tools/sema/cli.ts)
  local TOP=20
  local DEBUG=false
  local PATTERNS_DIR="$HOME/.config/fabric/patterns"
  [[ "$1" == "--debug" ]] && { DEBUG=true; shift; }

  # Stufe 1: Suchbegriff
  local query="${1:-}"
  if [[ -z "$query" ]]; then
    printf "\033[1;36m🔍 Semantic Search → Claude Code (Fabric AI)\033[0m\n"
    printf "Suchbegriff: "
    read -r query
    [[ -z "$query" ]] && { echo "Abgebrochen."; return 1; }
  fi

  # Suche ausfuehren
  printf "\033[0;33m⏳ Suche nach \"%s\" ...\033[0m\n" "$query"
  local raw_output
  raw_output=$("${SEMA_CLI[@]}" search "$query" --top "$TOP" 2>&1)
  local exit_code=$?

  $DEBUG && printf "[DEBUG] exit_code=%s, output_length=%s\n" "$exit_code" "${#raw_output}"
  $DEBUG && echo "[DEBUG] First 3 lines:" && echo "$raw_output" | head -3

  if [[ -z "$raw_output" ]] || [[ ${#raw_output} -lt 10 ]]; then
    echo "❌ Keine Ausgabe von sema CLI (exit: $exit_code)"
    return 1
  fi

  local file_lines
  file_lines=$(echo "$raw_output" | sed -n 's/^[[:space:]]*[0-9]*\.[[:space:]]*\(\[.*\]\)/\1/p')

  if [[ -z "$file_lines" ]]; then
    echo "❌ Konnte Ergebnisse nicht parsen."
    return 1
  fi

  local count=$(echo "$file_lines" | wc -l | tr -d ' ')
  printf "\033[0;32m✅ %s Treffer\033[0m\n\n" "$count"

  # Stufe 1b: Dateien waehlen mit fzf
  local selected
  selected=$(echo "$file_lines" | fzf \
    --multi \
    --prompt="Tab=markieren, Enter=fertig > " \
    --header="🔍 \"$query\" — $count Treffer" \
    --preview='f=$(echo {} | sed "s/^\[.*\] //"); head -40 "$f" 2>/dev/null || echo "Keine Preview"' \
    --preview-window=right:50%:wrap \
    --height=80% \
    --border=rounded)

  [[ -z "$selected" ]] && { echo "Abgebrochen."; return 1; }

  local paths
  paths=$(echo "$selected" | sed 's/^\[.*\] //')
  local selected_count=$(echo "$paths" | wc -l | tr -d ' ')
  printf "\n\033[0;32m📄 %s Datei(en) gewählt\033[0m\n\n" "$selected_count"

  # Stufe 2: Fabric Pattern waehlen
  local -a CURATED=(
    "── ANALYSIEREN & ERKLÄREN ───│"
    "extract_wisdom               │ Weisheit, Ideen, Zitate, Gewohnheiten extrahieren"
    "extract_insights             │ Die 10 überraschendsten Kernerkenntnisse"
    "analyze_prose                │ Schreibqualität bewerten + Verbesserungsvorschläge"
    "analyze_claims               │ Behauptungen auf Wahrheit prüfen (A-F Rating)"
    "analyze_paper                │ Wissenschaftliche Rigor-Analyse"
    "analyze_presentation         │ Präsentation reviewen und kritisch bewerten"
    "analyze_tech_impact          │ Technologie-Impact auf Gesellschaft analysieren"
    "find_logical_fallacies       │ Logikfehler und Fehlschlüsse finden"
    "explain_docs                 │ Dokumentation verständlich erklären"
    "explain_terms                │ Glossar aller wichtigen Begriffe erstellen"
    "rate_content                 │ Inhalt bewerten + Qualitäts-Rating (1-10)"
    "── ZUSAMMENFASSEN ───────────│"
    "summarize                    │ 1-Satz-Summary + 10 Hauptpunkte + 5 Takeaways"
    "create_summary               │ Strukturierte Markdown-Zusammenfassung"
    "create_5_sentence_summary    │ 5-Satz-Zusammenfassung"
    "extract_core_message         │ Kernbotschaft auf den Punkt"
    "── VERGLEICHEN ──────────────│"
    "compare_and_contrast         │ Markdown-Tabelle: Gemeinsamkeiten & Unterschiede"
    "── CONTENT ERSTELLEN ────────│"
    "write_essay                  │ Essay im Paul-Graham-Stil"
    "create_keynote               │ Keynote/Präsentation erstellen"
    "write_micro_essay            │ Micro-Essay (< 300 Wörter)"
    "improve_writing              │ Text überarbeiten: Klarheit, Kohärenz, Stil"
    "enrich_blog_post             │ Blog-Post anreichern und verbessern"
    "create_newsletter_entry      │ Newsletter-Abschnitt erstellen"
    "── EXTRAHIEREN ──────────────│"
    "extract_ideas                │ 20-50 überraschende Ideen"
    "extract_recommendations      │ Handlungsempfehlungen"
    "extract_questions            │ Offene Fragen identifizieren"
    "create_tags                  │ Tags und Kategorien generieren"
    "── LERNEN ───────────────────│"
    "create_flash_cards           │ Lernkarten für Schlüsselkonzepte"
    "create_quiz                  │ Quiz-Fragen zum Inhalt generieren"
    "── CUSTOM ──────────────────-│"
    "FREIE_FRAGE                  │ Eigene Frage an Claude Code"
    "ALLE_PATTERNS                │ Alle 239 Fabric Patterns durchsuchen"
  )

  local choice
  choice=$(printf '%s\n' "${CURATED[@]}" | fzf \
    --prompt="Pattern wählen > " \
    --header="🧠 Fabric AI Pattern für Claude Code" \
    --preview='p=$(echo {} | awk "{print \$1}");
              f="'"$PATTERNS_DIR"'/$p/system.md";
              if [[ -f "$f" ]]; then
                printf "\033[1;33m── %s ──\033[0m\n\n" "$p"
                head -30 "$f"
              else
                echo "📂 Kategorie-Header"
              fi' \
    --preview-window=right:50%:wrap \
    --height=80% \
    --border=rounded \
    --no-multi)

  [[ -z "$choice" ]] && { echo "Abgebrochen."; return 1; }

  local pattern
  pattern=$(echo "$choice" | awk '{print $1}')

  if [[ "$pattern" == "──" ]]; then
    echo "⚠️ Kategorie-Header, kein Pattern."
    return 1
  fi

  local action=""
  if [[ "$pattern" == "FREIE_FRAGE" ]]; then
    printf "\033[1;36mDeine Frage:\033[0m "
    read -r action
    [[ -z "$action" ]] && { echo "Abgebrochen."; return 1; }
  fi

  if [[ "$pattern" == "ALLE_PATTERNS" ]]; then
    pattern=$(ls "$PATTERNS_DIR" | fzf \
      --prompt="Pattern suchen > " \
      --header="🔍 Alle Fabric Patterns durchsuchen" \
      --preview='f="'"$PATTERNS_DIR"'/{}/system.md";
                if [[ -f "$f" ]]; then
                  printf "\033[1;33m── {} ──\033[0m\n\n"
                  head -30 "$f"
                else
                  echo "Keine system.md gefunden"
                fi' \
      --preview-window=right:50%:wrap \
      --height=80% \
      --border=rounded \
      --no-multi)
    [[ -z "$pattern" ]] && { echo "Abgebrochen."; return 1; }
  fi

  local file_list=""
  while IFS= read -r p; do
    file_list+="- $p"$'\n'
  done <<< "$paths"

  local prompt=""

  if [[ -n "$action" ]]; then
    prompt="$action

Basierend auf diesen Dateien (semantische Suche: \"$query\"):

$file_list
Lies bitte zuerst alle Dateien und arbeite dann die Aufgabe ab. Antworte auf Deutsch."
  else
    local pattern_file="$PATTERNS_DIR/$pattern/system.md"
    if [[ ! -f "$pattern_file" ]]; then
      echo "❌ Pattern-Datei nicht gefunden: $pattern_file"
      return 1
    fi

    local system_prompt
    system_prompt=$(cat "$pattern_file")

    prompt="SPRACHE: Deine gesamte Ausgabe MUSS auf Deutsch sein. Uebersetze ALLE englischen Section-Header ins Deutsche.

Du folgst diesem Analyse-Framework:

---
$system_prompt
---

Wende dieses Framework auf folgende Dateien an (semantische Suche: \"$query\"):

$file_list
Lies bitte zuerst alle Dateien vollstaendig und arbeite dann das Framework systematisch auf Deutsch ab."
  fi

  printf "\n\033[1;36m━━━ Claude Code Prompt ━━━\033[0m\n"
  if [[ -n "$action" ]]; then
    printf "\033[0;33mModus:\033[0m Freie Frage\n"
    printf "\033[0;33mFrage:\033[0m %s\n" "$action"
  else
    printf "\033[0;33mPattern:\033[0m %s\n" "$pattern"
    printf "\033[0;33mQuelle:\033[0m %s\n" "$PATTERNS_DIR/$pattern/system.md"
  fi
  printf "\033[0;33mDateien:\033[0m %s\n" "$selected_count"
  printf "\033[0;33mSuche:\033[0m \"%s\"\n" "$query"
  printf "\033[1;36m━━━━━━━━━━━━━━━━━━━━━━━━━\033[0m\n\n"

  if [[ ${#prompt} -gt 500 ]]; then
    echo "${prompt:0:300}"
    printf "\n\033[0;90m... (%s Zeichen, inkl. system.md) ...\033[0m\n\n" "${#prompt}"
    echo "${prompt: -150}"
  else
    echo "$prompt"
  fi

  printf "\n\033[1;32mEnter\033[0m = Starten, \033[1;31mCtrl+C\033[0m = Abbrechen "
  read -r

  printf "\n\033[0;33m🚀 Starte Claude Code mit Fabric Pattern \"%s\"...\033[0m\n" "${pattern:-custom}"
  claude "$prompt"
}