https://github.com/semcod/redsl
https://github.com/semcod/redsl
Last synced: 8 days ago
JSON representation
- Host: GitHub
- URL: https://github.com/semcod/redsl
- Owner: semcod
- License: apache-2.0
- Created: 2026-04-07T13:58:35.000Z (2 months ago)
- Default Branch: main
- Last Pushed: 2026-05-14T07:33:01.000Z (26 days ago)
- Last Synced: 2026-05-14T09:41:20.960Z (26 days ago)
- Language: Python
- Size: 90.4 MB
- Stars: 0
- Watchers: 0
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- License: LICENSE
Awesome Lists containing this project
README
## AI Cost Tracking
   
  
- 🤖 **LLM usage:** $7.5000 (114 commits)
- 👤 **Human dev:** ~$4622 (46.2h @ $100/h, 30min dedup)
Generated on 2026-05-14 using [openrouter/openai/gpt-5-mini](https://openrouter.ai/openai/gpt-5-mini)
---
**Re**factor + **DSL** + **S**elf-**L**earning — AI-Native DevOps & Refactoring OS
> ⚠️ **To nie jest zwykły DSL do wymagań. To autonomiczny system operacyjny dla AI-driven software engineering.**
ReDSL to eksperymentalny framework łączący LLM,
formalny runtime DSL, CI/CD i pętlę samorefaktoryzacji w jeden autonomiczny cykl życia kodu.
    [](./docs/)
---
## Aktualny stan projektu
Na podstawie analizy `code2llm` z 2026-04-09:
- **Pliki**: 114
- **Funkcje**: 781
- **Klasy**: 112
- **Linie kodu**: 19 151
- **Średnia złożoność**: CC̄ = 4.1
- **Hotspoty krytyczne**: 3
- **Duplikacje / cykle**: 0 / 0
- **Największy hotspot**: `redsl/formatters.py` (517 LOC, CC=28)
- **Następny refactor**: rozbić 3 metody o CC > 15:
- `format_cycle_report_markdown()`
- `format_batch_report_markdown()`
- `LLMLayer.call()`
---
## 🧠 Co to naprawdę jest ReDSL?
**Nie jest to tylko DSL do wymagań. To AI-driven software lifecycle system:**
| Komponent | Rola w systemie |
|-----------|-----------------|
| **SUMD** | Opis systemu (high-level spec) |
| **DOQL** | Runtime definicja aplikacji (CLI, workflows) |
| **taskfile** | Operacje DevOps |
| **testQL** | Walidacja |
| **pyqual** | System jakości kodu |
| **LLM** | Refaktoryzacja + automatyzacja (gpt-5-mini przez litellm) |
### 🔥 KLUCZOWA ZMIANA PARADYGMATU
❌ **Wcześniej (typowy DSL)**: opisujesz wymagania → generujesz dokumentację → ręczna interpretacja
✅ **Tutaj**: opisujesz system → system ma CI/CD, testy, linting, deployment, refactor pipeline → **LLM może ingerować w kod**
**To jest autonomiczny system developmentu.**
## 🏗️ Architektura: Autonomiczna Pętla
```
SUMD → DOQL → taskfile → pyqual → testQL → LLM refactor loop → deployment
```
### Szczegółowy flow:
```
┌─────────────────────────────────────────────────────────────────────┐
│ AUTONOMICZNY CYKL ŻYCIA KODU │
│ │
│ 🧾 SUMD ──► ⚙️ DOQL ──► 🔄 taskfile ──► 🧪 pyqual ──► 🤖 LLM │
│ │ │ │ │ │ │
│ ▼ ▼ ▼ ▼ ▼ │
│ [Spec] [Runtime] [DevOps] [Quality] [Refactor] │
│ │ │ │ │ │ │
│ └──────────┴───────────┴────────────┴───────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────┐ │
│ │ REFACTOR ORCHESTRATOR │ │
│ │ PERCEIVE → DECIDE → PLAN → EXECUTE │ │
│ │ ↓ ↓ │ │
│ │ REFLECT → REMEMBER → IMPROVE │ │
│ └─────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────┐ │
│ │ VALIDATION LAYER │ │
│ │ regix (regresja) │ vallm │ sandbox │ │
│ └─────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ [deployment] ◄── CI/CD ◄── quality gates ◄── auto-PR │
│ │
└─────────────────────────────────────────────────────────────────────┘
```
## 🚨 CO TU JEST NAPRAWDĘ NOWEGO
### 🧠 A. "Code as controllable system"
To NIE jest: kod + AI
To jest: **system operacyjny dla kodu**
### 🔁 B. Self-learning loop
Masz: testy, lint, quality gates, refactor pipeline, LLM model
👉 System, który może **sam poprawiać swój kod**
### 🧩 C. DSL = interfejs sterowania
DOQL to nie język deklaratywny - to **orkiestrator systemu**:
```yaml
workflow[name="test"] {
run pytest
}
```
## Kluczowe Funkcje
- 🔍 **Analiza statyczna** - Integracja z code2llm, toon.yaml, linterami (ruff, mypy, bandit)
- 🧠 **LLM z refleksją** - Generowanie propozycji refaktoryzacji z pętlą samorefleksji
- ⚡ **Hybrydowy silnik** - Bezpośrednie refaktoryzacje (bez LLM) dla prostych zmian
- 📊 **DSL Engine** - Definicja reguł refaktoryzacji w czytelnym formacie YAML
- 💾 **System pamięci** - Trzy warstwy: epizodyczna, semantyczna, proceduralna
- 🛡️ **Walidacja regresji** - Automatyczne wykrywanie degradacji metryk przez regix
- 🚀 **Skalowalność** - Przetwarzanie wielu projektów (semcod) jednocześnie
- 🐳 **Sandbox** - Bezpieczne testowanie refaktoryzacji w Docker
- 🔄 **Autonomy loop** - Perceive → Decide → Plan → Execute → Reflect → Memory Update
# Ze źródeł
git clone https://github.com/wronai/redsl
cd redsl
pip install -e .
```
### Wymagania
- Python >= 3.11
- Opcjonalnie: Docker (dla sandbox testing)
- Opcjonalnie: Narzędzia semcod ecosystem (code2llm, regix, pyqual, planfile)
# Refaktoryzacja pojedynczego projektu (dry-run → markdown)
redsl refactor ./my-project --max-actions 5 --dry-run
# Dry-run → bezpośrednio jako zadania w planfile.yaml
redsl refactor ./my-project --max-actions 5 --dry-run --to-planfile
# Wykonaj decyzje zapisane w planfile.yaml
redsl refactor ./my-project --from-planfile --from-planfile-path ./planfile.yaml
# Refaktoryzacja z walidacją regresji
redsl refactor ./my-project --max-actions 10 --validate-regix --rollback
# Refaktoryzacja z sandbox testing (Docker)
redsl refactor ./my-project --max-actions 5 --sandbox
# Analiza jakości kodu bez refaktoryzacji
redsl pyqual analyze ./my-project --format yaml
# Automatyczne naprawy jakościowe (bez LLM)
redsl pyqual fix ./my-project
```
# Hybrydowa refaktoryzacja (bez LLM) - szybka
redsl batch hybrid /path/to/semcod --max-changes 50
# Pełna refaktoryzacja z LLM i refleksją
redsl batch semcod /path/to/semcod --max-actions 10
# Z wykrywaniem regresji metryk przez regix
redsl batch semcod /path/to/semcod --max-actions 5 --validate-regix
```
Każde uruchomienie `refactor` oraz `batch` zapisuje też raport Markdown obok projektu lub katalogu root:
- `redsl_refactor_plan.md` — wynik `--dry-run` (domyślnie markdown)
- `redsl_refactor_report.md` — wykonany cykl refaktoryzacji
- `redsl_batch_semcod_report.md` — raport zbiorczy dla `batch semcod`
- `redsl_batch_hybrid_report.md` — raport zbiorczy dla `batch hybrid`
### Workflow planfile (rekomendowany)
Zamiast natychmiastowego wykonania, możesz przeglądnąć i zatwierdzić decyzje w planfile:
```bash
# 1. Generuj decyzje jako zadania planfile
redsl refactor ./my-project --dry-run --to-planfile -n 10
# 2. Sprawdź aktualność ticketów (czy plik istnieje, CC nadal przekroczony, czy nie wykonano już)
redsl planfile validate ./my-project
# 3. Opcjonalnie: usuń tickety już nieaktualne
redsl planfile validate ./my-project --fix
# 4. Przejrzyj i edytuj ./my-project/planfile.yaml (odznacz lub usuń niechciane zadania)
# 5. Wykonaj tylko zatwierdzone zadania
redsl refactor ./my-project --from-planfile
```
### Walidacja ticketów (`redsl planfile validate`)
Sprawdza czy każde otwarte zadanie w `planfile.yaml` jest nadal aktualne:
| Werdykt | Znaczenie |
|---|---|
| `OK` | Plik istnieje, metryka wciąż przekroczona |
| `STALE_FILE_MISSING` | Plik wskazany w tickecie nie istnieje |
| `STALE_FIXED` | CC pliku jest teraz poniżej progu (problem sam się rozwiązał) |
| `STALE_APPLIED` | Akcja już wykonana i zapisana w `history.jsonl` |
```bash
redsl planfile validate ./my-project # raport
redsl planfile validate ./my-project --fix # oznacza stale jako 'stale' w planfile.yaml
redsl planfile validate ./my-project --json # output JSON do pipe/jq
```
# Sprawdź konfigurację i zmienne środowiskowe
redsl debug config --show-env
# Zobacz decyzje DSL dla projektu
redsl debug decisions ./my-project --limit 20
# Profiluj wydajność cyklu refaktoryzacji
redsl perf ./my-project
# Szacuj koszt LLM przed uruchomieniem
redsl cost ./my-project --max-actions 10
```
## Przykłady
| Katalog | Opis | Link |
|---------|------|------|
| `examples/01-basic-analysis/` | Analiza projektu z plików toon.yaml | [Przejdź](./examples/01-basic-analysis/) |
| `examples/02-custom-rules/` | Definiowanie własnych reguł DSL | [Przejdź](./examples/02-custom-rules/) |
| `examples/03-full-pipeline/` | Pełny cykl: analyze → decide → refactor → reflect | [Przejdź](./examples/03-full-pipeline/) |
| `examples/04-memory-learning/` | System pamięci: episodic, semantic, procedural | [Przejdź](./examples/04-memory-learning/) |
| `examples/05-api-integration/` | Użycie REST API i WebSocket | [Przejdź](./examples/05-api-integration/) |
| `examples/06-awareness/` | Świadomość zmian i adaptacja | [Przejdź](./examples/06-awareness/) |
| `examples/07-pyqual/` | Quality gates i analiza jakości | [Przejdź](./examples/07-pyqual/) |
| `examples/08-audit/` | One-click Audit → ocena A+ do F | [Przejdź](./examples/08-audit/) |
| `examples/09-pr-bot/` | PR Bot z metrykami delta | [Przejdź](./examples/09-pr-bot/) |
| `examples/10-badge/` | Generator badge'i jakości | [Przejdź](./examples/10-badge/) |
# Uruchomienie przykładu przez CLI
redsl example 01-basic-analysis
# Lub bezpośrednio
python examples/01-basic-analysis/main.py
```
## REST API
ReDSL udostępnia REST API (FastAPI) do programatycznego dostępu do wszystkich funkcji:
# Wbudowany serwer (uvicorn)
redsl server --host 0.0.0.0 --port 8000
# Lub bezpośrednio
python -m redsl.server
```
### Endpointy
| Endpoint | Metoda | Opis |
|----------|--------|------|
| `/health` | GET | Health check + wersja + statystyki pamięci |
| `/refactor` | POST | Uruchom refaktoryzację projektu |
| `/analyze` | POST | Analiza projektu — zwraca metryki i alerty |
| `/decide` | POST | Ewaluacja reguł DSL — decyzje bez wykonania |
| `/rules` | POST | Dodaj niestandardowe reguły DSL |
| `/memory/stats` | GET | Statystyki pamięci agenta |
| `/debug/config` | GET | Konfiguracja agenta (z opcjonalnym `?show_env=true`) |
| `/debug/decisions` | GET | Decyzje DSL dla projektu (`?project_path=&limit=`) |
| `/examples` | GET | Lista dostępnych przykładów |
| `/examples/{name}/yaml` | GET | Surowe dane YAML scenariusza |
# Health check
curl http://localhost:8000/health
# Analiza projektu
curl -X POST http://localhost:8000/analyze \
-H "Content-Type: application/json" \
-d '{"project_dir": "./my-project"}'
# Refaktoryzacja (dry-run)
curl -X POST http://localhost:8000/refactor \
-H "Content-Type: application/json" \
-d '{"project_path": "./my-project", "max_actions": 3, "dry_run": true, "format": "yaml"}'
# Dodaj własną regułę DSL
curl -X POST http://localhost:8000/rules \
-H "Content-Type: application/json" \
-d '{"rules": [{"name": "my-rule", "condition": {"metric": "cc", "operator": ">", "threshold": 10}, "action": "refactor", "priority": 0.9}]}'
```
### Skanowanie zdalnego repozytorium (Marketing / Outreach)
```bash
# Skan repozytorium przez URL — zwraca metryki i top issues
curl -s -X POST http://localhost:8000/scan/remote \
-H "Content-Type: application/json" \
-d '{"repo_url":"https://github.com/semcod/pyqual","branch":"main","depth":1}' | jq .
# CQRS: asynchroniczny skan (zwraca correlation_id, status via query)
curl -s -X POST http://localhost:8000/cqrs/scan/remote \
-H "Content-Type: application/json" \
-d '{"repo_url":"https://github.com/semcod/pyqual","branch":"main","async_mode":true}' | jq .
# Query status skanu
curl -s "http://localhost:8000/cqrs/query/scan/status?repo_url=https://github.com/semcod/pyqual" | jq .
# CQRS: rozpocznij refaktoryzację
curl -s -X POST http://localhost:8000/cqrs/refactor \
-H "Content-Type: application/json" \
-d '{"project_dir":"./my-project","dry_run":true,"max_actions":5}' | jq .
# WebSocket: stream zdarzeń w czasie rzeczywistym (wymaga wscat lub websocat)
websocat ws://localhost:8000/ws/cqrs/events
```
## Marketing Hub (Cold Email & LinkedIn Outreach)
ReDSL zawiera stronę marketingową (`www/marketing/`) do generowania personalizowanych wiadomości outreach na podstawie skanu repozytorium:
| Funkcja | Endpoint | Opis |
|---------|----------|------|
| **Formularz skanu** | `POST /marketing/` | Wklej URL repo → generuje szablony email/LinkedIn/GitHub |
| **Tech Lead** | Email | "Znalazłem 3 rzeczy w [repo] które spowalniają development" |
| **CEO** | Email | "Wasz projekt — znalazłem coś co spowalnia team" |
| **PM Agencji** | Email | "Jak pokazujecie klientom postęp w jakości kodu?" |
| **LinkedIn** | Post | Hook na ból, kontrintuicja AI, case study przed/po |
| **GitHub** | Issue | Cold outreach do OSS project |
```bash
# Uruchomienie lokalne (wymaga PHP + ReDSL API na porcie 8001)
cd www && php -S localhost:9999 -t .
# Otwórz: http://localhost:9999/marketing/
```
**Testy Marketing Hub:**
```bash
# E2E Playwright (3 przeglądarki × 17 testów)
cd www/tests/e2e && npx playwright test marketing-hub.spec.js --reporter=line
# PHP Unit tests (wymaga rozszerzeń dom, xml, xmlwriter)
php vendor/bin/phpunit tests/MarketingHubTest.php
```
## ⚖️ Markdown + AI vs ReDSL — Porównanie
Twoje wcześniejsze porównanie trzeba zmienić.
### 📝 Markdown + AI
- input: luźny tekst
- AI interpretuje
- brak twardej struktury systemu
- **To jest asystent**
### 🧠 ReDSL (ten projekt)
- input: strukturalny system (SUMD + DOQL)
- AI działa w **kontrolowanym runtime**
- ma pipeline jakości + CI/CD + refactor loop
- **To jest autonomiczny system zarządzania cyklem życia kodu**
| Kryterium | Markdown + AI | ReDSL |
|-----------|---------------|-------|
| **UX** | ✅ Wygrywa | ⚠️ Złożony |
| **Adopcja** | ✅ Łatwy start | ⚠️ Wysoki koszt wejścia |
| **Prostota** | ✅ Intuicyjny | ⚠️ Wiele abstrakcji |
| **Kontrola systemu** | ❌ Brak | ✅ Deterministyczny runtime |
| **Automatyzacja lifecycle** | ❌ Manualna | ✅ Auto-pipeline |
| **CI/CD + AI integration** | ❌ Brak | ✅ Natywne |
| **Deterministyczność** | ❌ Niedeterministyczna | ✅ DSL-driven |
**Wniosek**: Markdown + AI wygrywa w produktywności i UX. ReDSL wygrywa **tylko jeśli** AI development stanie się w pełni autonomiczny i firmy zaakceptują "system DSL jako runtime devops".
## 🧾 Realna Ocena Projektu
| Kryterium | Ocena | Uzasadnienie |
|-----------|-------|--------------|
| 🧠 **Innowacyjność** | **9/10** | Blisko Devin, Auto-refactoring systems, AI CI/CD pipelines |
| ⚙️ **Techniczna spójność** | **8.5/10** | Pełny pipeline dev, quality system, docker + CI + LLM |
| 🚧 **Praktyczna adopcja** | **6/10** | Bardzo złożony, wysoki koszt wejścia, brak standardu rynkowego |
| 📉 **Ryzyko** | **Wysokie** | Dużo abstrakcji DSL, dependency na LLM, brak dowodów produkcyjnego użycia |
### 🎯 FINALNA KONKLUZJA
👉 **To NIE jest już "DSL do wymagań"**
👉 **To jest: eksperymentalny system operacyjny dla AI-driven software engineering**
- ❌ To nie jest zwykły DSL
- ❌ To nie jest konkurencja do Markdown (inna kategoria)
- 🟢 To jest **AI-native DevOps + refactoring OS**
- 🟡 Bardzo ambitne, ale ciężkie do wdrożenia
## Architektura Szczegółowa
```
┌─────────────────────────────────────────────────────────────────┐
│ REFACTOR ORCHESTRATOR │
│ PERCEIVE → DECIDE → PLAN → EXECUTE → REFLECT │
│ ↓ ↓ │
│ REMEMBER → IMPROVE (auto-learning) │
├─────────────────┬───────────────────┬───────────────────────────┤
│ ANALYZER │ DSL ENGINE │ REFACTOR ENGINES │
│ ─ toon.yaml │ ─ rule scoring │ ┌─────────────────────┐ │
│ ─ code2llm │ ─ decisions │ │ DirectRefactorEngine│ │
│ ─ linters │ ─ auto-learning │ │ (bez LLM) │ │
│ ─ redup │ │ ├─────────────────────┤ │
│ │ │ │ LLM RefactorEngine │ │
│ │ │ │ (z refleksją) │ │
│ │ │ └─────────────────────┘ │
├─────────────────┴───────────────────┴───────────────────────────┤
│ VALIDATION LAYER │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────┐ │
│ │ regix │ │ vallm │ │ sandbox (Docker) │ │
│ │ (regression)│ │ (pactfix) │ │ (bezpieczne testowanie) │ │
│ └─────────────┘ └─────────────┘ └─────────────────────────┘ │
├─────────────────────────────────────────────────────────────────┤
│ ECOSYSTEM BRIDGES │
│ code2llm │ regix │ pyqual │ planfile │ vallm │ redup │ llx │
├─────────────────────────────────────────────────────────────────┤
│ LLM LAYER (LiteLLM) │
│ ─ model routing (llx_router) ─ cost estimation ─ reflection │
├─────────────────────────────────────────────────────────────────┤
│ MEMORY SYSTEM │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────┐ │
│ │ episodic │ │ semantic │ │ procedural │ │
│ │ (historia) │ │ (wzorce) │ │ (strategie) │ │
│ └─────────────┘ └─────────────┘ └─────────────────────┘ │
└─────────────────────────────────────────────────────────────────┘
```
### Proste akcje (bez LLM)
- `REMOVE_UNUSED_IMPORTS` - Usuwanie nieużywanych importów
- `FIX_MODULE_EXECUTION_BLOCK` - Poprawa bloków wykonania modułu
- `EXTRACT_CONSTANTS` - Ekstrakcja magic numbers do stałych
- `ADD_RETURN_TYPES` - Dodawanie adnotacji typów zwracanych
> **Uwaga implementacyjna:** deterministyczne helpery AST znajdują się teraz w `redsl/refactors/ast_transformers.py`, a `redsl.refactors` oraz `redsl.refactors.direct` re-exportują je dla zachowania kompatybilności.
### Złożone akcje (z LLM)
- `EXTRACT_FUNCTIONS` - Ekstrakcja funkcji o wysokiej złożoności
- `SPLIT_MODULE` - Podział dużych modułów
- `REDUCE_COMPLEXITY` - Redukcja złożoności cyklomatycznej
- `SIMPLIFY_CONDITIONALS` - Upraszczanie warunków
- `DEDUPLICATE` - Usuwanie duplikacji kodu
### Szybki smoke test
Jeśli chcesz szybko sprawdzić, czy ReDSL uruchamia się poprawnie w nowym projekcie, użyj minimalnego projektu z jednym plikiem:
```bash
mkdir -p /tmp/redsl-smoke
cat > /tmp/redsl-smoke/main.py <<'PY'
import os
def main() -> None:
return None
main()
PY
python3 -m redsl analyze /tmp/redsl-smoke
python3 -m redsl refactor /tmp/redsl-smoke --dry-run --max-actions 5
```
# Tylko szybkie testy (< 5s każdy)
pytest -m 'not slow'
# Tylko testy e2e (full workflows na realnych projektach)
pytest tests/test_e2e.py -v
```
**Struktura testów:**
- **776+ collected tests** — testy jednostkowe i integracyjne (~20s z pytest-xdist)
- **18 e2e tests** — pełne przepływy CLI i API na realnych projektach
- **20 integration tests** — integracja z semcod ecosystem (code2llm, regix, pyqual)
- **15 Playwright tests** — E2E GUI (Marketing Hub, 3 przeglądarki)
**Pokrycie e2e:**
- CLI: `refactor`, `history`, `ecosystem`, `scan`, `batch pyqual-run`
- API: `/health`, `/refactor`, `/analyze`, `/decide`, `/rules`, `/memory/stats`, `/debug/config`, `/debug/decisions`, `/examples`, `/scan/remote`, CQRS commands/queries
- Autonomy: quality gate workflow
- GUI: Marketing Hub form, tabs, copy buttons, responsive design
## Obserwowalność i historia decyzji
Każdy cykl refaktoryzacji zapisuje zdarzenia do pliku `.redsl/history.jsonl` w katalogu projektu. Jest to append-only log JSON Lines.
### Typy zdarzeń
| Zdarzenie | Kiedy | Kluczowe pola |
|-----------|-------|---------------|
| `cycle_started` | Start cyklu | `llm_model`, `workflow_source`, `max_actions`, `flags` |
| `cycle_completed` | Koniec cyklu | `status`, `proposals_applied`, `proposals_generated`, `proposals_rejected`, `errors` |
| `validator_gates_passed` | Wszystkie quality gates OK | `metrics` |
| `validator_gates_failed` | Przynajmniej jedna brama nie przeszła | `failed_gates` |
| `validator_tune_applied` | Tune auto-fix zastosowany | `retries_used` |
| `validator_tune_failed` | Tune nieudany po max retries | `retries_used`, `reason` |
| `validator_tune_no_metrics` | Brak metryk, uruchomiono `pyqual run` | — |
| `cycle_rollback` | Wyjątek w cyklu → rollback plików | `files_rolled_back` |
```bash
# Przeglądaj historię projektu
redsl history show ./my-project
# Tylko cykl_completed zdarzenia
cat ./my-project/.redsl/history.jsonl | grep '"cycle_completed"' | jq .
```
## Konfiguracja workflow (`redsl.yaml`)
Plik `redsl.yaml` w katalogu projektu steruje pełnym pipeline'em. Kluczowe sekcje:
```yaml
decide:
max_actions: 10
llm_model: auto # lub np. "openrouter/anthropic/claude-3.5-sonnet"
llm_temperature: null # null = domyślny model default
tune:
strategy: auto # auto | aggressive
retry: 2 # liczba prób auto-fix
run_on_missing_metrics: true # uruchom pyqual run gdy brak metryk
create_planfile_task_on_failure: true # utwórz task w planfile po nieudanym tune
```
Pole `llm_model: auto` oznacza, że redsl korzysta z ustawień środowiskowych (`LLM_MODEL` lub domyślnego routera llx). Można nadpisać per-projekt.
## Ekosystem Semcod (opcjonalne narzędzia)
ReDSL integruje się z ekosystemem semcod dla wzmocnionej analizy:
| Narzędzie | Bridge | Funkcja |
|-----------|--------|---------|
| `code2llm` | `code2llm_bridge.py` | Generowanie plików toon.yaml z metrykami |
| `regix` | `regix_bridge.py` | Wykrywanie regresji metryk po refaktoryzacji |
| `pyqual` | `pyqual_bridge.py` | Analiza jakości kodu (ruff, mypy, bandit) |
| `planfile` | `planfile_bridge.py` | Tworzenie ticketów dla refactoring tasks |
| `vallm` | `vallm_bridge.py` | Walidacja poprawności kodu przez LLM |
| `redup` | `redup_bridge.py` | Detekcja duplikacji kodu (`redup==0.4.18`) |
| `llx` | `llx_router.py` | Inteligentny routing modeli LLM |
| `sumd` | `sumd_bridge.py` | Natywna analiza AST (CC, fan-out, hotspoty) - alternatywa dla code2llm |
| `testql` | `testql_bridge.py` | Walidacja API po refaktoryzacji - testy regresyjne |
# Klucz API dla LLM (wymagany dla akcji z LLM)
OPENROUTER_API_KEY (set in your environment)
# Model LLM (domyślnie: openrouter/moonshotai/kimi-k2.5)
LLM_MODEL=openrouter/moonshotai/kimi-k2.5
# Zachowanie refaktoryzacji
REFACTOR_DRY_RUN=false
REFACTOR_AUTO_APPROVE=false
REFACTOR_MAX_REFLECTION_ROUNDS=1
# Pamięć agenta
MEMORY_PERSIST_DIR=.redsl_memory
# Lokalne modele (Ollama) - wymagają ollama serve
OLLAMA_HOST=http://localhost:11434
# Timeout dla narzędzi zewnętrznych
REDSL_REGIX_TIMEOUT=300
```
### Plik `redsl.yaml` (reguły DSL)
```yaml
project:
name: my-project
source: ./
output: ./docs/
# Reguły refaktoryzacji
rules:
- name: high_complexity
condition: cyclomatic_complexity > 15
action: EXTRACT_FUNCTIONS
priority: 0.9
- name: unused_imports
condition: unused_import_count > 5
action: REMOVE_UNUSED_IMPORTS
priority: 0.8
# Wykluczenia z analizy
exclude:
- .venv/
- venv/
- node_modules/
- .git/
- tests/
```
## Opcje CLI
```bash
redsl refactor --help
Options:
-n, --max-actions INTEGER Maksymalna liczba akcji
--dry-run Pokaż plan bez aplikowania zmian
-f, --format [text|yaml|json] Format wyjścia
--use-code2llm Użyj code2llm do percepcji
--validate-regix Walidacja regresji po wykonaniu
--rollback Auto-rollback przy regresji
--sandbox Testuj w Docker sandbox
```
## Struktura projektu
```
redsl/
├── redsl/
│ ├── analyzers/ # Analiza kodu, metryki, code2llm/redup bridge
│ ├── commands/ # Komendy CLI: batch, pyqual, planfile bridge
│ ├── dsl/ # Silnik reguł DSL i scoring
│ ├── llm/ # Warstwa LLM (LiteLLM) + llx router
│ ├── memory/ # System pamięci (3 warstwy)
│ ├── refactors/ # Silniki: Direct + LLM + body_restorer
│ ├── validation/ # regix, vallm, test_runner, sandbox
│ ├── diagnostics/ # Profilowanie: perf_bridge (metrun)
│ ├── orchestrator.py # Główny koordynator pipeline
│ ├── cli.py # Punkt wejścia CLI
│ └── config.py # AgentConfig, LLMConfig
├── tests/ # 776+ testów (fast + e2e + integration + Playwright)
├── examples/ # Przykłady użycia
├── config/ # Domyślna konfiguracja reguł DSL
└── pyproject.toml # Packaging i zależności
```
## Dokumentacja
Szczegółowa dokumentacja projektów ekosystemu **semcod** dostępna w katalogu [`docs/`](./docs/):
### Narzędzia Core (Pipeline)
| Projekt | Dokumentacja | Opis |
|---------|--------------|------|
| **ReDSL** | [`docs/README.md`](./docs/README.md) | Autonomiczny system refaktoryzacji (ten projekt) |
| **Config Standard** | [`docs/CONFIG_STANDARD.md`](./docs/CONFIG_STANDARD.md) | Bezpieczna konfiguracja YAML + sekrety |
| **Config Migration** | [`docs/CONFIG_MIGRATION.md`](./docs/CONFIG_MIGRATION.md) | Przewodnik migracji z env vars |
| **Config Cheatsheet** | [`docs/CONFIG_CHEATSHEET.md`](./docs/CONFIG_CHEATSHEET.md) | Ściągawka komend i referencji |
| [code2llm](https://github.com/semcod/code2llm) | [`docs/code2llm-analiza-przeplywu-kodu.md`](./docs/code2llm-analiza-przeplywu-kodu.md) | Analiza przepływu kodu, generowanie TOON |
| [code2logic](https://github.com/semcod/code2logic) | [`docs/code2logic-analiza-nlp.md`](./docs/code2logic-analiza-nlp.md) | NLP dla zapytań o kod (polski/angielski) |
| [regix](https://github.com/semcod/regix) | [`docs/regix-indeks-regresji.md`](./docs/regix-indeks-regresji.md) | Wykrywanie regresji metryk między commitami |
| [redup](https://github.com/semcod/redup) | [`docs/redup-detekcja-duplikacji.md`](./docs/redup-detekcja-duplikacji.md) | Detekcja duplikacji na poziomie AST |
| [pyqual](https://github.com/semcod/pyqual) | [`docs/pyqual-quality-gates.md`](./docs/pyqual-quality-gates.md) | Quality gates: ruff + mypy + bandit |
| [vallm](https://github.com/semcod/vallm) | [`docs/vallm-walidacja-kodu-llm.md`](./docs/vallm-walidacja-kodu-llm.md) | Walidacja kodu LLM |
### Automatyzacja i CI/CD
| Projekt | Dokumentacja | Opis |
|---------|--------------|------|
| [planfile](https://github.com/semcod/planfile) | [`docs/planfile-automatyzacja-sdlc.md`](./docs/planfile-automatyzacja-sdlc.md) | Automatyzacja cyklu SDLC |
| [goal](https://github.com/semcod/goal) | [`docs/goal-automatyczny-git-push.md`](./docs/goal-automatyczny-git-push.md) | Automatyczne commity i release'y |
| [domd](https://github.com/semcod/domd) | [`docs/domd-walidacja-komend-markdown.md`](./docs/domd-walidacja-komend-markdown.md) | Walidacja komend w Markdown |
| [qualbench](https://github.com/semcod/qualbench) | [`docs/qualbench-ci-dla-kodu-ai.md`](./docs/qualbench-ci-dla-kodu-ai.md) | Benchmarki CI dla kodu AI |
| [weekly](https://github.com/semcod/weekly) | [`docs/weekly-analizator-jakosci.md`](./docs/weekly-analizator-jakosci.md) | Analizator jakości projektu |
### Infrastruktura LLM
| Projekt | Dokumentacja | Opis |
|---------|--------------|------|
| [proxym](https://github.com/semcod/proxym) | [`docs/proxym-proxy-ai.md`](./docs/proxym-proxy-ai.md) | Proxy AI z cache'm semantycznym |
| [llx](https://github.com/semcod/llx) | [`docs/llx-routing-modeli-llm.md`](./docs/llx-routing-modeli-llm.md) | Routing modeli LLM |
| [prellm](https://github.com/semcod/prellm) | [`docs/prellm-preprocessing-llm.md`](./docs/prellm-preprocessing-llm.md) | Preprocessing zapytań LLM |
| [algitex](https://github.com/semcod/algitex) | [`docs/algitex-progresywna-algorytmizacja.md`](./docs/algitex-progresywna-algorytmizacja.md) | Progresywna algorytmizacja |
### Narzędzia Deweloperskie
| Projekt | Dokumentacja | Opis |
|---------|--------------|------|
| [pfix](https://github.com/semcod/pfix) | [`docs/pfix-self-healing-python.md`](./docs/pfix-self-healing-python.md) | Self-healing Python |
| [prefact](https://github.com/semcod/prefact) | [`docs/prefact-linter-llm-aware.md`](./docs/prefact-linter-llm-aware.md) | Linter świadomy LLM |
| [pactfix](https://github.com/semcod/pactfix) | [`docs/pactfix-bash-analyzer.md`](./docs/pactfix-bash-analyzer.md) | Analizator Bash |
| [clickmd](https://github.com/semcod/clickmd) | [`docs/clickmd-markdown-terminal.md`](./docs/clickmd-markdown-terminal.md) | Markdown w terminalu |
| [toonic](https://github.com/semcod/toonic) | [`docs/toonic-format-toon.md`](./docs/toonic-format-toon.md) | Format TOON |
### Monitoring i Koszty
| Projekt | Dokumentacja | Opis |
|---------|--------------|------|
| [costs](https://github.com/semcod/costs) | [`docs/cost-kalkulator-kosztow-ai.md`](./docs/cost-kalkulator-kosztow-ai.md) | Kalkulator kosztów AI |
| [nfo](https://github.com/semcod/nfo) | [`docs/nfo-automatyczne-logowanie-funkcji.md`](./docs/nfo-automatyczne-logowanie-funkcji.md) | Auto-logowanie funkcji |
| [metrun](https://github.com/semcod/metrun) | [`docs/metrun-profilowanie-wydajnosci.md`](./docs/metrun-profilowanie-wydajnosci.md) | Profilowanie wydajności |
| [ats-benchmark](https://github.com/semcod/ats-benchmark) | [`docs/ats-benchmark.md`](./docs/ats-benchmark.md) | Benchmarki automatyzacji |
### Ekosystem i Biznes
| Projekt | Dokumentacja | Opis |
|---------|--------------|------|
| [Ekosystem](https://github.com/semcod) | [`docs/ekosystem-semcod-przeglad.md`](./docs/ekosystem-semcod-przeglad.md) | Przegląd ekosystemu (29 narzędzi) |
| [Biznes](https://github.com/semcod) | [`docs/zautomatyzowany-biznes-semcod.md`](./docs/zautomatyzowany-biznes-semcod.md) | Model biznesowy Semcod |
| [code2docs](https://github.com/semcod/code2docs) | [`docs/code2docs-automatyczna-dokumentacja.md`](./docs/code2docs-automatyczna-dokumentacja.md) | Auto-dokumentacja |
### Inne projekty
- [heal](./docs/heal-zdrowie-wellness.md) — Wellness z LLM
---
## License
Licensed under Apache-2.0.
## Status
_Last updated by [taskill](https://github.com/oqlos/taskill) at 2026-04-25 13:46 UTC_
| Metric | Value |
|---|---|
| HEAD | `ddbf5bb` |
| Coverage | — |
| Failing tests | — |
| Commits in last cycle | 50 |
> Mostly documentation fixes and broad refactorings; autonomy_pr was restructured into a package with new analyzer/reporter modules, i18n pricing text improved, and test tooling updated (pytest-xdist / test optimizations).