KAOS/TASKS/Implementation-Tasks.md

# KAOS v0.1 — Implementacioni taskovi

**Verzija:** 0.1.0
**Poslednje ažuriranje:** 2026-02-20

---

## Pregled

V0.1 cilj: supervisor koji pokreće Claude Code agente, prati izvršavanje,
verifikuje rezultat, piše izveštaj. Ručno pokretanje, markdown taskovi.

---

## T01: Inicijalizacija Go projekta

**Status:** pending
**Agent:** coder
**Model:** Sonnet
**Zavisi od:** —

**Opis:**
Kreirati Go projekat u `code/` folderu sa osnovnom strukturom.

**Fajlovi za kreiranje:**
```
code/
├── go.mod                     ← module github.com/dal/kaos
├── .env.example               ← KAOS_TIMEOUT=30m
├── .gitignore                 ← Go defaults + .env
├── Makefile                   ← build, test, vet, clean
├── cmd/
│   └── kaos-supervisor/
│       └── main.go            ← entry point (prazan skeleton)
├── internal/
│   ├── config/
│   │   └── config.go          ← čita .env, drži config struct
│   └── supervisor/
│       └── supervisor.go      ← prazan skeleton
└── CLAUDE.md                  ← pravila kodiranja (kopija agents/coder/CLAUDE.md)
```

**Pravila:**
- `go mod init github.com/dal/kaos`
- Go 1.22+
- Makefile targeti: `build`, `test`, `vet`, `clean`, `all`
- Config čita iz .env: KAOS_TIMEOUT, KAOS_PROJECT_PATH
- Svaki fajl mora imati package doc komentar

**Test:**
- `go build ./...` prolazi
- `go vet ./...` prolazi
- Config test: učitaj .env.example, proveri da su vrednosti popunjene

**Očekivani izlaz:**
Projekat se kompajlira. `make build` kreira binary. `make test` prolazi.

---

## T02: Task loader — parsiranje markdown taskova

**Status:** pending
**Agent:** coder
**Model:** Sonnet
**Zavisi od:** T01

**Opis:**
Supervisor mora da čita taskove iz markdown fajla (ovog fajla).
Parsira sekcije, izvlači ID, status, zavisnosti.

**Fajlovi za kreiranje:**
```
code/internal/supervisor/
├── task.go          ← Task struct, LoadTasks(), FindTask(), NextTask()
└── task_test.go     ← testovi sa primer markdown-om
```

**Task struct:**
```go
type Task struct {
    ID          string   // T01, T02...
    Title       string   // naslov
    Status      string   // pending, running, done, failed
    Agent       string   // coder, checker, frontend...
    Model       string   // Haiku, Sonnet, Opus
    DependsOn   []string // lista task ID-eva
    Description string   // ceo opis
}
```

**Funkcije:**
- `LoadTasks(mdPath string) ([]Task, error)` — parsira markdown
- `FindTask(tasks []Task, id string) *Task` — nađi po ID-u
- `NextTask(tasks []Task) *Task` — prvi pending čije su zavisnosti done
- `UpdateStatus(mdPath, taskID, newStatus string) error` — promeni status u fajlu

**Test:**
- LoadTasks sa primer markdown-om → parsira tačno
- NextTask vraća pravi task po zavisnostima
- UpdateStatus menja fajl korektno
- Edge case: nema pending taskova, cirkularna zavisnost

**Očekivani izlaz:**
`go test ./internal/supervisor/ -v` — svi testovi zeleni.

---

## T03: Runner — pokretanje Claude Code

**Status:** pending
**Agent:** coder
**Model:** Sonnet
**Zavisi od:** T02

**Opis:**
Pokreće Claude Code sa task promptom, prati stdout/stderr u realnom vremenu,
meri vreme, čuva exit code.

**Fajlovi za kreiranje:**
```
code/internal/supervisor/
├── runner.go        ← RunTask(), priprema prompt, pokreće claude CLI
└── runner_test.go   ← test sa mock komandom (ne pravi claude)
```

**Funkcije:**
```go
type RunResult struct {
    TaskID      string
    StartedAt   time.Time
    FinishedAt  time.Time
    Duration    time.Duration
    ExitCode    int
    Output      string
    Error       string
}

func RunTask(task Task, projectPath string, timeout time.Duration) RunResult
```

**Prompt koji šalje Claude Code-u:**
```
Radi na KAOS projektu.
Tvoj task: {ID} — {Title}
Pročitaj CLAUDE.md u root-u projekta za pravila rada.
{Description}
Kad završiš: go build, go test, commituj, pushuj.
```

**Test:**
- Mock: umesto `claude` pokreni `echo "done"` — proveri da RunResult ima tačne podatke
- Timeout: pokreni `sleep 999` sa timeout 1s — proveri da se prekine
- Output capture: proveri da stdout/stderr su uhvaćeni

**Očekivani izlaz:**
RunTask pokrene proces, uhvati output, meri vreme, poštuje timeout.

---

## T04: Checker — verifikacija posle agenta

**Status:** pending
**Agent:** coder
**Model:** Sonnet
**Zavisi od:** T01

**Opis:**
Posle svake Claude Code sesije, nezavisno pokrene build + test + vet.

**Fajlovi za kreiranje:**
```
code/internal/supervisor/
├── checker.go       ← Verify(), CheckResult struct
└── checker_test.go  ← test sa privremenim Go projektom
```

**Funkcije:**
```go
type CheckResult struct {
    Name     string        // "build", "test", "vet"
    Status   string        // "pass", "fail"
    Output   string
    Duration time.Duration
    TestCount int          // samo za test check
}

type VerifyResult struct {
    Build CheckResult
    Vet   CheckResult
    Test  CheckResult
    AllPassed bool
}

func Verify(projectPath string) VerifyResult
```

**Test:**
- Napravi temp Go projekat koji prolazi — Verify vraća AllPassed=true
- Napravi temp Go projekat sa syntax error — Build fail
- Napravi temp Go projekat sa failing test — Test fail
- Proveri da TestCount parsira tačno

**Očekivani izlaz:**
Verify pokrene tri komande, parsira rezultat, vrati struct.

---

## T05: Reporter — pisanje izveštaja

**Status:** pending
**Agent:** coder
**Model:** Sonnet
**Zavisi od:** T03, T04

**Opis:**
Generiše markdown izveštaj posle izvršenog taska.

**Fajlovi za kreiranje:**
```
code/internal/supervisor/
├── reporter.go      ← WriteReport()
└── reporter_test.go
```

**Funkcije:**
```go
func WriteReport(
    task Task,
    run RunResult,
    verify VerifyResult,
    reportsDir string,
) (string, error)  // vraća putanju do izveštaja
```

**Format izveštaja:**
```markdown
# T{XX}: Naslov

**Datum:** 2026-02-20 10:15
**Trajanje:** 8m 45s
**Status:** ✅ Završen / ❌ Neuspešan

## Verifikacija
- ✅/❌ go build    (0.3s)
- ✅/❌ go vet      (0.2s)
- ✅/❌ go test     (12/12 testova, 2.1s)

## Agent output
(skraćen output Claude Code sesije)

## Commit
- Hash: a1b2c3d
- Branch: main
```

**Test:**
- WriteReport sa mock podacima → fajl postoji, sadržaj tačan
- Proveri format datuma, trajanja
- Proveri da folder kreira ako ne postoji

**Očekivani izlaz:**
`TASKS/reports/T01-report.md` se generiše sa tačnim sadržajem.

---

## T06: CLI — komandni interfejs

**Status:** pending
**Agent:** coder
**Model:** Sonnet
**Zavisi od:** T02, T03, T04, T05

**Opis:**
Entry point — parsira komande, poziva supervisor funkcije.

**Fajlovi za izmenu:**
```
code/cmd/kaos-supervisor/main.go   ← komande
```

**Komande:**
```bash
kaos-supervisor run [TASK_ID]    # pokreni task (ili sledeći ako bez ID)
kaos-supervisor status           # prikaži status svih taskova
kaos-supervisor next             # prikaži šta je sledeće
kaos-supervisor verify           # ponovo pokreni verifikaciju
kaos-supervisor history          # prikaži izvršene taskove iz reports/
```

**Pravila:**
- Bez eksternih CLI biblioteka (flag package dovoljno)
- Svaka komanda ima --help
- Formatiran terminal output (emoji za status)
- Poruke na srpskom

**Test:**
- `kaos-supervisor status` sa primer taskovima → ispravan output
- `kaos-supervisor next` → vraća pravi task
- Nepoznata komanda → help poruka

**Očekivani izlaz:**
`make build` → `bin/kaos-supervisor` radi sve komande.

---

## T07: Integracija — sve zajedno

**Status:** pending
**Agent:** coder
**Model:** Sonnet
**Zavisi od:** T06

**Opis:**
End-to-end tok: učitaj taskove → pokreni → verifikuj → izveštaj → ažuriraj status.

**Fajlovi za izmenu:**
```
code/internal/supervisor/
├── supervisor.go    ← Run() koji povezuje sve korake
└── supervisor_test.go
```

**Funkcija:**
```go
func (s *Supervisor) Run(taskID string) error {
    // 1. Učitaj taskove
    // 2. Nađi task (po ID-u ili NextTask)
    // 3. Proveri zavisnosti
    // 4. Postavi status: running
    // 5. Pokreni Claude Code (RunTask)
    // 6. Verifikuj (Verify)
    // 7. Napiši izveštaj (WriteReport)
    // 8. Postavi status: done ili failed
    // 9. Prikaži rezultat
}
```

**Test:**
- End-to-end sa mock Claude Code komandom
- Task sa neispunjenom zavisnošću → greška
- Task koji je već done → skip ili greška
- Failed verifikacija → status=failed, izveštaj navede šta palo

**Očekivani izlaz:**
`kaos-supervisor run T01` prolazi ceo tok od učitavanja do izveštaja.

---

## Redosled izvršavanja

```
T01 (Go init)
 │
 ├── T02 (Task loader)
 │    │
 │    └── T03 (Runner)
 │         │
 │         └── T05 (Reporter) ──┐
 │                               │
 └── T04 (Checker) ─────────────┘
                                 │
                            T06 (CLI)
                                 │
                            T07 (Integracija)
```

**Quality gates:**
- Posle T01: `make build` i `make test` prolaze
- Posle T04: Verify radi na test projektu
- Posle T06: Sve komande rade iz terminala
- Posle T07: End-to-end tok radi sa mock agentom