Stwórz zaawansowaną aplikację LM

Rozumiem: chcesz niebanalny projekt powiązany z LM-ami, pisaniem i codziennym kodowaniem w stylu Codex/Cloud Code. Najpierw szybko sprawdzę kontekst repo, potem zaproponuję jeden mocny kierunek i od razu przygotuję starter projektu.

Użyję skilla vibe-coding-mastery, bo dokładnie dotyczy startu nowego projektu AI od pomysłu do planu wdrożenia. Teraz czytam jego workflow i na tej bazie przygotuję konkretny koncept plus starter.

Mam już zasady skilla. Teraz wezmę szablony dokumentacji i od razu wygeneruję Ci realny „starter projektu” (nie tylko pomysł), żebyś mógł od razu ruszyć z implementacją.

Zamiast samych pomysłów robię od razu działający zalążek: aplikację typu „kompilator kontekstu dla agenta kodującego” (briefy, plan, drift specyfikacji, gotowe prompty do Codexa). Za chwilę tworzę strukturę projektu i pliki kanoniczne + MVP CLI.

Teraz tworzę konkretny projekt contextforge: dokumentację kanoniczną + działające CLI (TypeScript), które kompiluje kontekst i prompty dla agenta kodującego na bazie specyfikacji oraz diffa. Po tym odpalę build i szybki test poleceniem CLI.

Jadę dalej: tworzę teraz wszystkie pliki projektu i implementację CLI, a potem od razu odpalę kompilację oraz przykładowe uruchomienie, żeby potwierdzić że działa end-to-end.

Szkielet narzędziowy już jest (package.json, TypeScript, gitignore). Teraz dokładam rdzeń logiki: parser specyfikacji/diffa, scoring ryzyk i generator promptów do planera, implementera i reviewera.

Silnik CLI jest już wstawiony. Teraz domykam dokumentację projektową (PRD + flow + stack + plan) i zasady sesji (CLAUDE.md, progress.txt), żeby projekt był gotowy pod długofalową pracę z agentami.

Pliki są gotowe, przechodzę do weryfikacji wykonania: instalacja zależności, build TypeScript i testowe compile, żeby potwierdzić że generuje artefakty bez ręcznych poprawek.

Widzę drobną poprawkę językową w raporcie ryzyk i ją teraz nanoszę, żeby output był czysty. Potem zrobię szybki rebuild kontrolny.

Walidacja przeszła, więc aktualizuję jeszcze progress.txt, żeby stan projektu był spójny na kolejne sesje. Potem podsumuję dokładnie co jest gotowe.

Zbudowałem nowy projekt: ContextForge w ​/Users/wojciechkapala/develop/zabawa/contextforge.

To nie jest basic appka typu chat. To kompilator kontekstu dla Codex/Cloud Code:

• czyta task + spec + diff,
• liczy pokrycie wymagań,
• wykrywa ryzyka regresji,
• generuje gotowy pakiet promptów dla 3 ról: planner/coder/reviewer.

Najważniejsze pliki:

• ​/Users/wojciechkapala/develop/zabawa/contextforge/src/cli.ts
• ​/Users/wojciechkapala/develop/zabawa/contextforge/src/core/analyzer.ts
• ​/Users/wojciechkapala/develop/zabawa/contextforge/src/core/promptBuilder.ts
• `​/Users/wojciechka

Biorę to w całości: dołożę teraz 3 rzeczy naraz w ContextForge - testy jednostkowe, integrację z OpenAI (semantyczny drift) i działający WebUI z endpointem API. Najpierw sprawdzę obecny stan kodu i potem od razu wejdę w edycję.

Użyję teraz dwóch skilli: vibe-coding-mastery (utrzymanie workflow i artefaktów projektu) oraz openai-docs (żeby integracja Responses API była zgodna z aktualnym API). Najpierw pobieram aktualne endpointy i minimalny payload.

Teraz przechodzę do warstwy WebUI i zgodnie z zasadami użyję też skilla frontend-design, żeby interfejs nie był generyczny. Najpierw biorę jego minimalne wytyczne, potem robię web/ + serwer API.

Plan wdrożenia (robię wszystko bez zatrzymywania):

1. Rozszerzam backend o moduł semantyczny OpenAI (/v1/responses) z bezpiecznym fallbackiem, gdy brak OPENAI_API_KEY.
2. Integruję to w CLI (--semantic, --model) i dodaję raport semantyczny do artefaktów.
3. Dodaję testy jednostkowe (analyzer, promptBuilder, semantics) z uruchamianiem przez npm test.
4. Buduję WebUI (web/ + src/web/server.ts) z endpointem /api/compile, rendererem ryzyk/pokrycia/promptów i trybem semantic toggle.
5. Aktualizuję README + docs + progress i odpalam walidację end-to-end (build, test, CLI, smoke

Zaczynam od zmian w typach i rdzeniu, żeby później testy i UI bazowały na stabilnym kontrakcie danych (semantic, merge ryzyk, plan additions).

Przechodzę do WebUI: dodaję lekki serwer HTTP z API /api/compile i panel webowy (web/index.html, web/styles.css, web/app.js) z widokiem ryzyk, pokrycia i promptów.

Dodaję teraz testy jednostkowe dla trzech obszarów: parser/analyzer, generator promptów i parser semantyczny. Potem podłączę je do npm test.

Kończę warstwę produktową: aktualizuję README i dokumenty kanoniczne tak, by odzwierciedlały nowe funkcje (OpenAI semantic + WebUI + testy), potem robię pełną walidację komend.

Kod i dokumentacja są już spięte. Uruchamiam teraz pełną walidację: build, test, potem CLI z --semantic (fallback bez klucza) i smoke test WebUI API.

Testuję teraz WebUI jako działający produkt: uruchomię serwer, uderzę w /api/health i /api/compile, potem go zamknę. To potwierdzi end-to-end bez ręcznego klikania.

Zrobione. ContextForge ma teraz testy, integrację OpenAI i WebUI.

Co dodałem

• OpenAI semantic drift (/v1/responses) + merge ryzyk i planu:
  semantics.ts
• Integracja semantic mode w CLI (--semantic, --model, --openai-base-url) + semantic-report.md:
  cli.ts
• Web API + serwer statyczny (/api/compile, /api/sample-spec, /api/git-diff, /api/health):
  server.ts
• WebUI (input task/spec/diff