Builds und Tests ausführen

greppy bash-smart führt einen Build-, Test- oder Lint-Befehl unverändert aus und behält seinen Exit-Code. Zurück kommen ein einzeiliges Urteil, die Fehler- und Warnungsblöcke und ein Log, dessen lange Strecken gefaltet sind, statt komplett gedruckt zu werden. Dein Agent sieht das Entscheidende zuerst, und nichts geht verloren: Die Rohausgabe bleibt abrufbar.

greppy bash-smart -- cargo test
greppy bash-smart -- npm run build
greppy bash-smart -e 'panicked at' -- cargo test

Der Agent-Prompt sagt Agenten, jeden Build-, Test- oder Lint-Befehl so auszuführen. Siehe Agent-Setup.

Ein Testlauf mit einem Fehler

Das Beispiel ist ein kleines Python-Projekt mit 380 Tests, einer davon schlägt fehl: slugify("Rust & Python") liefert rust---python statt rust-python.

greppy bash-smart -- python3 -m unittest -v

FAILED — exit 1: 4 errors, 0 warnings
383  FAIL: test_slug_07 (tests.test_textkit.SlugifyTest.test_slug_07)
…
392  AssertionError: 'rust---python' != 'rust-python'
401  FAILED (failures=1)
… partial output — raw log "/var/folders/hf/x8jpryjx6xs8k0kwmkj5spkw0000gn/T/greppy-bash-smart-501/5460-1791407870089721000.stdout"; read with greppy read-file
test_clamp_00 (tests.test_textkit.ClampTest.test_clamp_00) ... ok
…
test_clamp_109 (tests.test_textkit.ClampTest.test_clamp_109) ... ok
… lines 22-320 (299 collapsed lines) — raw log "/var/folders/hf/x8jpryjx6xs8k0kwmkj5spkw0000gn/T/greppy-bash-smart-501/5460-1791407870089721000.stderr"; read with greppy read-file
test_slug_00 (tests.test_textkit.SlugifyTest.test_slug_00) ... ok
… lines 322-327 (6 collapsed lines) — raw log "/var/folders/hf/x8jpryjx6xs8k0kwmkj5spkw0000gn/T/greppy-bash-smart-501/5460-1791407870089721000.stderr"; read with greppy read-file
328:test_slug_07 (tests.test_textkit.SlugifyTest.test_slug_07) ... FAIL
test_slug_08 (tests.test_textkit.SlugifyTest.test_slug_08) ... ok
… lines 330-341 (12 collapsed lines) — raw log "/var/folders/hf/x8jpryjx6xs8k0kwmkj5spkw0000gn/T/greppy-bash-smart-501/5460-1791407870089721000.stderr"; read with greppy read-file
…
Ran 380 tests in 0.006s

FAILED (failures=1)

Zuerst kommen Urteil und Fehlerblock, jede Zeile mit ihrer Nummer in der Rohausgabe. Danach folgt das Log: der Anfang, die gefalteten Strecken, die hervorgehobene Zeile 328 mit dem fehlschlagenden Test und das komplette Ende mit Traceback und Zusammenfassung. Der Exit-Code ist der von unittest, hier 1.

Gefaltete Zeilen zurückholen

Jede Faltung nennt, wie du an die Zeilen kommst. Mit Expansion-Speicher endet sie mit — greppy expand ID, und greppy expand ID druckt die gespeicherten Rohzeilen seitenweise, mit --offset und --limit gezielt. Im Lauf oben war der Expansion-Speicher belegt; dann nennt die Faltung die Rohlog-Datei, und greppy read-file holt die Zeilen.

greppy read-file /var/folders/hf/x8jpryjx6xs8k0kwmkj5spkw0000gn/T/greppy-bash-smart-501/5460-1791407870089721000.stderr --lines 320:329

/private/var/folders/hf/x8jpryjx6xs8k0kwmkj5spkw0000gn/T/greppy-bash-smart-501/5460-1791407870089721000.stderr:320-329
test_clamp_99 (tests.test_textkit.ClampTest.test_clamp_99) ... ok
test_slug_00 (tests.test_textkit.SlugifyTest.test_slug_00) ... ok
test_slug_01 (tests.test_textkit.SlugifyTest.test_slug_01) ... ok
test_slug_02 (tests.test_textkit.SlugifyTest.test_slug_02) ... ok
test_slug_03 (tests.test_textkit.SlugifyTest.test_slug_03) ... ok
test_slug_04 (tests.test_textkit.SlugifyTest.test_slug_04) ... ok
test_slug_05 (tests.test_textkit.SlugifyTest.test_slug_05) ... ok
test_slug_06 (tests.test_textkit.SlugifyTest.test_slug_06) ... ok
test_slug_07 (tests.test_textkit.SlugifyTest.test_slug_07) ... FAIL
test_slug_08 (tests.test_textkit.SlugifyTest.test_slug_08) ... ok

Rohes stdout und stderr bleiben byte-genau erhalten: Die Vorschau ersetzt nie den Mitschnitt, und ein fehlschlagender Befehl bleibt ein Fehlschlag. Die vollständigen Regeln stehen im Display-Vertrag.

Das Urteil

Zeile 1 ist das Urteil, mit Exit-Code und den gezählten Fehler- und Warnungsblöcken:

ok — exit 0
FAILED — exit 1: 1 error, 0 warnings
FAILED — exit 1: 4 errors, 0 warnings

Danach kommen die Fehler- und Warnungsblöcke und jede Zeile, die auf ein -e REGEX passt. Der Rest wird kompakt und abrufbar. Der Exit-Code von bash-smart ist der Exit-Code des Befehls, Skripte und CI behandeln es also genau wie das Original.

Was du siehst

Ausgabe	Anzeige
Kurze Ausgabe (bis 80 Zeilen insgesamt)	einmal nach dem Urteil, auf ihrem ursprünglichen stdout- oder stderr-Stream; die Diagnosen stehen nicht noch einmal davor, ihre Zahl steht im Urteil
Längere Ausgabe	zuerst Fehler- und Warnungsblöcke, dann das Log mit gefalteten Strecken; jede Faltung nennt `greppy expand ID` oder die Rohlog-Datei
Eine einzelne Zeile über 4096 Bytes	Vorschau aus den ersten 2048 und den letzten 1024 Bytes plus Hinweis auf die ausgelassenen Bytes und die Rohlog-Datei
Timeouts und unterbrochene Ausgabe	behalten ihr Diagnose-Präfix und ihr Recovery-Paket

Zeilen hervorheben

-e REGEX hebt jede passende Zeile eines langen Logs über die gefaltete Ausgabe, mit ihrer Zeilennummer. Für mehrere Muster wiederholst du es:

greppy bash-smart -e 'test_clamp_150' -e '^Ran ' -- python3 -m unittest -v

FAILED — exit 1: 4 errors, 0 warnings
383  FAIL: test_slug_07 (tests.test_textkit.SlugifyTest.test_slug_07)
…
401  FAILED (failures=1)
67  test_clamp_150 (tests.test_textkit.ClampTest.test_clamp_150) ... ok
399  Ran 380 tests in 0.005s
…

Befehle, Umgebung und Pipelines

bash-smart führt das argv nach -- direkt aus.

Eingabe	Verhalten
führende `VAR=value`-Tokens	werden Umgebungsvariablen des Kindprozesses
Shell-Builtins und Operatoren	übergibst du als einen gequoteten Ausdruck; ungequotete Shell-Syntax lehnt greppy mit Exit 64 ab und zeigt die gequotete Form
gequotete Ausdrücke	laufen in Bash mit `pipefail`, ein fehlschlagender Producer wird also nicht von einem erfolgreichen `tail` oder `grep` verdeckt

$ greppy bash-smart -- GREETING=hallo python3 -c 'import os; print(os.environ["GREETING"])'
ok — exit 0
hallo
$ greppy bash-smart -- cd tests
greppy: invalid request: bash-smart received unquoted shell syntax; pass the complete shell expression as one quoted argument, for example `greppy bash-smart -- "cd DIR && COMMAND"`
$ greppy bash-smart -- 'python3 -m unittest 2>&1 | tail -n 3'
FAILED — exit 1: 1 error, 0 warnings
Ran 380 tests in 0.009s

FAILED (failures=1)

Der zweite Befehl endet mit Exit 64, der dritte mit Exit 1, obwohl tail selbst erfolgreich war.

Lang laufende Befehle

Druckt ein Befehl 15 Sekunden lang nichts, schreibt bash-smart ein Lebenszeichen auf stderr, danach eines pro Minute. Es nennt die PID des direkten Kindprozesses und die verstrichene Zeit. So hält niemand einen aktiven cargo- oder Testlauf für einen toten Wrapper, während seine Ausgabe mitgeschnitten wird.

greppy bash-smart -- 'sleep 80; echo fertig'

bash-smart: command still running — pid=16694, elapsed=15s; child output is being captured and will be summarized on exit
bash-smart: command still running — pid=16694, elapsed=75s; child output is being captured and will be summarized on exit
ok — exit 0
fertig

Wenn der Index beschäftigt ist

bash-smart wartet nicht auf die Indexierung. Hält gerade ein Indexer den Store des Repositorys, startet der Befehl sofort, und nur die optionale Expansion-Speicherung entfällt. greppy meldet das mit bash-smart: index writer active; command execution continues without expansion storage; long output stays compact with raw-log paths instead of expand IDs. Das Falten funktioniert weiter und nennt die Rohlog-Datei statt einer Expand-ID.

Im eingebauten Agenten

Der eingebaute Agent hat genau ein Tool, greppy, und führt seine Befehle darüber als bash-smart -- CMD aus. So erreicht Build-Ausgabe das Modell kompakt.