Ze źródeł

AI Cost Tracking

🤖 LLM usage: $7.5000 (113 commits)
👤 Human dev: ~$4572 (45.7h @ $100/h, 30min dedup)

Generated on 2026-05-03 using openrouter/openai/gpt-5-mini

Refactor + DSL + Self-Learning — 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.

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:

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`

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)

# 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

# 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:

# 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:

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:

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

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/:

Narzędzia Core (Pipeline)

Projekt	Dokumentacja	Opis
ReDSL	`docs/README.md`	Autonomiczny system refaktoryzacji (ten projekt)
Config Standard	`docs/CONFIG_STANDARD.md`	Bezpieczna konfiguracja YAML + sekrety
Config Migration	`docs/CONFIG_MIGRATION.md`	Przewodnik migracji z env vars
Config Cheatsheet	`docs/CONFIG_CHEATSHEET.md`	Ściągawka komend i referencji
code2llm	`docs/code2llm-analiza-przeplywu-kodu.md`	Analiza przepływu kodu, generowanie TOON
code2logic	`docs/code2logic-analiza-nlp.md`	NLP dla zapytań o kod (polski/angielski)
regix	`docs/regix-indeks-regresji.md`	Wykrywanie regresji metryk między commitami
redup	`docs/redup-detekcja-duplikacji.md`	Detekcja duplikacji na poziomie AST
pyqual	`docs/pyqual-quality-gates.md`	Quality gates: ruff + mypy + bandit
vallm	`docs/vallm-walidacja-kodu-llm.md`	Walidacja kodu LLM

Automatyzacja i CI/CD

Projekt	Dokumentacja	Opis
planfile	`docs/planfile-automatyzacja-sdlc.md`	Automatyzacja cyklu SDLC
goal	`docs/goal-automatyczny-git-push.md`	Automatyczne commity i release'y
domd	`docs/domd-walidacja-komend-markdown.md`	Walidacja komend w Markdown
qualbench	`docs/qualbench-ci-dla-kodu-ai.md`	Benchmarki CI dla kodu AI
weekly	`docs/weekly-analizator-jakosci.md`	Analizator jakości projektu

Infrastruktura LLM

Projekt	Dokumentacja	Opis
proxym	`docs/proxym-proxy-ai.md`	Proxy AI z cache'm semantycznym
llx	`docs/llx-routing-modeli-llm.md`	Routing modeli LLM
prellm	`docs/prellm-preprocessing-llm.md`	Preprocessing zapytań LLM
algitex	`docs/algitex-progresywna-algorytmizacja.md`	Progresywna algorytmizacja

Narzędzia Deweloperskie

Projekt	Dokumentacja	Opis
pfix	`docs/pfix-self-healing-python.md`	Self-healing Python
prefact	`docs/prefact-linter-llm-aware.md`	Linter świadomy LLM
pactfix	`docs/pactfix-bash-analyzer.md`	Analizator Bash
clickmd	`docs/clickmd-markdown-terminal.md`	Markdown w terminalu
toonic	`docs/toonic-format-toon.md`	Format TOON

Monitoring i Koszty

Projekt	Dokumentacja	Opis
costs	`docs/cost-kalkulator-kosztow-ai.md`	Kalkulator kosztów AI
nfo	`docs/nfo-automatyczne-logowanie-funkcji.md`	Auto-logowanie funkcji
metrun	`docs/metrun-profilowanie-wydajnosci.md`	Profilowanie wydajności
ats-benchmark	`docs/ats-benchmark.md`	Benchmarki automatyzacji

Ekosystem i Biznes

Projekt	Dokumentacja	Opis
Ekosystem	`docs/ekosystem-semcod-przeglad.md`	Przegląd ekosystemu (29 narzędzi)
Biznes	`docs/zautomatyzowany-biznes-semcod.md`	Model biznesowy Semcod
code2docs	`docs/code2docs-automatyczna-dokumentacja.md`	Auto-dokumentacja

Inne projekty

heal — Wellness z LLM

License

Licensed under Apache-2.0.

Status

Last updated by 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).

Name		Name	Last commit message	Last commit date
Latest commit History 129 Commits
.goal		.goal
.idea		.idea
.planfile		.planfile
.taskill		.taskill
app		app
config		config
docs		docs
examples		examples
logs		logs
project		project
project_test		project_test
redsl		redsl
redsl_output		redsl_output
test_refactor_bad		test_refactor_bad
test_refactor_project		test_refactor_project
test_sample_project		test_sample_project
tests		tests
vallm_analysis		vallm_analysis
vallm_analysis_full		vallm_analysis_full
vallm_json		vallm_json
vallm_text		vallm_text
www		www
.code2llmignore		.code2llmignore
.gitignore		.gitignore
.pre-commit-config.yaml		.pre-commit-config.yaml
.redup_ignore		.redup_ignore
.vallmignore		.vallmignore
CHANGELOG.md		CHANGELOG.md
Dockerfile		Dockerfile
LICENSE		LICENSE
Makefile		Makefile
README.md		README.md
README_EN.md		README_EN.md
SUMD.md		SUMD.md
SUMR.md		SUMR.md
TODO.md		TODO.md
Taskfile.yml		Taskfile.yml
VERSION		VERSION
app.doql.css		app.doql.css
docker-compose.yml		docker-compose.yml
goal.yaml		goal.yaml
planfile.yaml		planfile.yaml
prefact.yaml		prefact.yaml
project.sh		project.sh
pyproject.toml		pyproject.toml
pyqual.yaml		pyqual.yaml
pyqual_report.yaml		pyqual_report.yaml
redsl_refactor_report.md		redsl_refactor_report.md
redsl_refactor_report.toon.yaml		redsl_refactor_report.toon.yaml
redsl_scan_report.md		redsl_scan_report.md
requirements.txt		requirements.txt
sumd.json		sumd.json
tree.sh		tree.sh
uv.lock		uv.lock
vallm.toml		vallm.toml

Folders and files

Latest commit

History

Repository files navigation

AI Cost Tracking

Aktualny stan projektu

🧠 Co to naprawdę jest ReDSL?

🔥 KLUCZOWA ZMIANA PARADYGMATU

🏗️ Architektura: Autonomiczna Pętla

Szczegółowy flow:

🚨 CO TU JEST NAPRAWDĘ NOWEGO

🧠 A. "Code as controllable system"

🔁 B. Self-learning loop

🧩 C. DSL = interfejs sterowania

Kluczowe Funkcje

Ze źródeł

Hybrydowa refaktoryzacja (bez LLM) - szybka

Pełna refaktoryzacja z LLM i refleksją

Z wykrywaniem regresji metryk przez regix

Walidacja ticketów (redsl planfile validate)

Sprawdź konfigurację i zmienne środowiskowe

Zobacz decyzje DSL dla projektu

Profiluj wydajność cyklu refaktoryzacji

Szacuj koszt LLM przed uruchomieniem

REST API

Wbudowany serwer (uvicorn)

Lub bezpośrednio

Skanowanie zdalnego repozytorium (Marketing / Outreach)

Marketing Hub (Cold Email & LinkedIn Outreach)

⚖️ Markdown + AI vs ReDSL — Porównanie

📝 Markdown + AI

🧠 ReDSL (ten projekt)

🧾 Realna Ocena Projektu

🎯 FINALNA KONKLUZJA

Architektura Szczegółowa

Proste akcje (bez LLM)

Złożone akcje (z LLM)

Szybki smoke test

Tylko szybkie testy (< 5s każdy)

Tylko testy e2e (full workflows na realnych projektach)

Konfiguracja workflow (redsl.yaml)

Ekosystem Semcod (opcjonalne narzędzia)

Klucz API dla LLM (wymagany dla akcji z LLM)

Model LLM (domyślnie: openrouter/moonshotai/kimi-k2.5)

Zachowanie refaktoryzacji

Pamięć agenta

Lokalne modele (Ollama) - wymagają ollama serve

Timeout dla narzędzi zewnętrznych

Opcje CLI

Struktura projektu

Dokumentacja

Narzędzia Core (Pipeline)

Automatyzacja i CI/CD

Infrastruktura LLM

Narzędzia Deweloperskie

Monitoring i Koszty

Ekosystem i Biznes

Inne projekty

License

Status

About

Resources

License

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Uh oh!

Contributors

Uh oh!

Languages

Walidacja ticketów (`redsl planfile validate`)

Konfiguracja workflow (`redsl.yaml`)

Packages