##  [Effektiv prompting fra kommandolinjen med Nushell completions](/da/node/152) 

    *Indsendt af Lennart den man, 16 feb 2026 - 12:49*  

 Når du arbejder med LLM'er fra kommandolinjen, kan det være kedeligt og fejlbehæftet at konstruere velstrukturerede prompts. Jeg byggede for nylig et Nushell-modul, der udnytter brugerdefinerede fuldførelser til at gøre promptgenerering interaktiv og konsekvent.

I stedet for at huske promptstrukturer eller kopiere fra en notatfil, giver dette modul dig mulighed for at opbygge prompter trin for trin med tab-fuldførelse. Systemet understøtter både engelsk og dansk med tre konfigurerbare komponenter:

- **Roller**: Definer, hvem AI'en skal agere som (f.eks. journalist, advokat, kommunikator)
- **Opgaver**: Angiv, hvad AI'en skal gøre (f.eks. opsummere, analysere, udvide)
- **Formater**: Styr outputstilen (f.eks. visuel liste, langt dokument, LinkedIn-opslag)

Brugen ser sådan ud:

```
"noget længere kontekst input her..." | prompt da rolle opgave format
# Tab gennem muligheder for sprog, rolle, opgave og format
# Få en komplet struktureret prompt klar til din LLM

```

## Brugerdefinerede fuldførelser: Den hemmelige ingrediens

Den virkelige styrke kommer fra Nushells brugerdefinerede fuldførelsessystem. Her er mønsteret:

```
export def da [
  role: string@da_roller
  task: string@da_opgaver
  format: string@da_formater
] { ... }

def da_roller [] {
  open ~/.config/nushell/modules/prompt/da_roller.nuon
}

```

Suffikset `@da_roller` fortæller Nushell at bruge `da_roller`-funktionen til tab-fuldførelse. Når du skriver `da ` og trykker Tab, får du en menu med tilgængelige roller. Fuldførelsesfunktionen returnerer simpelthen listen fra en datafil, så du kan administrere muligheder eksternt.

Dette er postbaseret.

For den listebaserede `dali`-kommando er der mere kompleks filtrering:

```
def da_prompts [args: string] {
  open ~/.config/nushell/modules/prompt/da_prompts.nuon | where value not-in ( $args | split words )
}

```

Dette filtrerer allerede valgte muligheder fra, hvilket forhindrer dubletter, når der bruges variadic argumenter.

## Datadrevet arkitektur med .nuon-filer

I stedet for at hardkode prompter i modulet bruger jeg `.nuon`-filer for vedligeholdelsesvenlighed. Hver fil indeholder en array af poster:

```
[
  {
    value: "Journalist"
    description: "Persona for undersøgende reporter"
    prompt: "Antag en persona som undersøgende journalist. Vær faktuel og skelne bekræftede fakta fra usikkerheder."
  }
  {
    value: "Advokat"
    description: "Persona for juridisk professionel"
    prompt: "Skriv som en advokat: præcis og objektiv. Strukturér efter fakta, juridisk grundlag og risici."
  }
]

```

Denne struktur med tre felter (`value`, `description`, `prompt`) tjener flere formål:

- `value`: Fuldførelsesnøglen og referenceidentifikatoren
- `description`: Vises i fuldførelsesmenuen for læsbarhed
- `prompt`: Den faktiske tekst, der indsættes i den endelige prompt

Adskillelse af data fra logik betyder, at du kan tilføje nye roller, opgaver eller formater ved at redigere en JSON-lignende fil uden at røre funktionskoden.

## Pipeline-først funktionsdesign

Implementeringen udnytter Nushells pipeline-inputmønster:

```
export def da [
  role: string@da_roller
  task: string@da_opgaver
  format: string@da_formater
] {
  let context = $in
  let roller = open ~/.config/nushell/modules/prompt/en_roller.nuon
  let opgaver = open ~/.config/nushell/modules/prompt/en_opgaver.nuon
  let formater = open ~/.config/nushell/modules/prompt/en_formater.nuon

  $roller | where value == $role | get prompt | str prepend 'ROLLE: '
  | append ($opgaver | where value == $task | get prompt | str prepend 'OPGAVE: ')
  | append ($formater | where value == $format | get prompt | str prepend 'FORMAT: ')
  | append "KONTEKST:"
  | append $context
  | to text --no-newline
}

```

Variablen `$in` fanger pipeline-input som kontekst. Funktionen læser derefter de tre datafiler, filtrerer for de valgte værdier og samler den endelige prompt ved at:

1. Hente promptteksten for hver komponent
2. Præfikse sektionsetiketter (ROLLE:, OPGAVE:, FORMAT:)
3. Tilføje de originale kontekstdata
4. Konvertere alt til en enkelt tekststreng

Denne tilgang transformerer rå data til produktionsklar prompter med en konsekvent struktur.

## Tekniske implementeringsdetaljer

Et par nøglemønstre får dette til at virke:

**Fil I/O til fuldførelser**: Hver fuldførelsesfunktion bruger `open` til at læse den tilsvarende `.nuon`-fil. Dette holder fuldførelserne synkroniseret med tilgængelige data automatisk.

**`where`-klausulfiltrering**: `where value == $role` uddrager den korrekte prompt fra data-arrayet. `value`-feltet fungerer som både fuldførelsesnøglen og opslagsreferencen.

**Pipeline-samling**: Brug af `| append` kæder opbygger prompten trin for trin. Hver tilføjelse bevarer pipeline-flowet, hvilket gør datatransformationen eksplicit.

**Endeligt output**: `to text --no-newline` konverterer den strukturerede liste til en enkelt streng uden at tilføje ekstra nye linjer, hvilket er afgørende for LLM-kompatibilitet.

## Udvidelse af systemet

Tilføjelse af nye promptkomponenter er ligetil:

1. Opret en ny `.nuon`-fil, der følger `{value, description, prompt}`-strukturen
2. Skriv en fuldførelsesfunktion, der læser og returnerer filen
3. Tilføj fuldførelsesreferencen til din funktionssignatur
4. Inkluder prompt-samlingslogikken i funktionskroppen

For nye sprog ville du oprette parallelle `.nuon`-filer (som `fr_roller.nuon`, `fr_opgaver.nuon`) og tilsvarende fuldførelsesfunktioner. Hovedfunktionen behøver blot at referere til de sprogspecifikke filer.

## Hvorfor dette mønster virker

Denne tilgang eksemplificerer shell-filosofi: gør én ting godt og komponer. Hver fuldførelsesfunktion har et enkelt ansvar - at returnere en liste over muligheder. Hovedfunktionen orkestrerer disse muligheder til en brugbar prompt. Datafilerne fungerer som et konfigurationslag, der forbinder de to.

For Nushell-udviklere, der arbejder med LLM'er, tilbyder dette mønster en skabelon til at bygge interaktive, komponerbare værktøjer, der gør gentagne opgaver hurtigere og mere konsekvente. Brugerdefinerede fuldførelser giver en poleret brugeroplevelse, mens den modulære datastruktur sikrer vedligeholdelse, efterhånden som dit promptbibliotek vokser.

Uanset om du bygger et promptsystem, en konfigurationsguide eller et hvilket som helst CLI-værktøj i flere trin, giver Nushells fuldførelsessystem kombineret med pipeline-funktioner dig et kraftfuldt fundament at arbejde ud fra.