diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 4cf88ce..840f555 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -7,7 +7,7 @@ on: jobs: tests: - name: Tests (546, unittest) + name: Tests (unittest) runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 @@ -98,9 +98,21 @@ jobs: - name: Xcode 16 kiezen (project-format 77 vereist dit) run: | - ls /Applications | grep Xcode || true - sudo xcode-select -s /Applications/Xcode_16*.app/Contents/Developer || \ + ls /Applications | grep -i xcode || true + # De glob mag niet als kale string doorgegeven worden: de shell zet + # meerdere matches om in één onbruikbaar argument. Kies bewust de + # nieuwste Xcode 16-bundel die echt een Contents/Developer heeft. + XCODE_APP="" + for kandidaat in $(ls -d /Applications/Xcode_16*.app 2>/dev/null | sort -Vr); do + if [ -d "$kandidaat/Contents/Developer" ]; then XCODE_APP="$kandidaat"; break; fi + done + if [ -n "$XCODE_APP" ]; then + echo "Xcode gekozen: $XCODE_APP" + sudo xcode-select -s "$XCODE_APP/Contents/Developer" + else + echo "Geen bruikbare Xcode_16*-bundel — terug naar de standaard-Xcode." sudo xcode-select -s /Applications/Xcode.app/Contents/Developer + fi xcodebuild -version - name: XcodeGen (pinned 2.46.0) diff --git a/IMPLEMENTATION_PROGRESS.md b/IMPLEMENTATION_PROGRESS.md new file mode 100644 index 0000000..26a4a76 --- /dev/null +++ b/IMPLEMENTATION_PROGRESS.md @@ -0,0 +1,39 @@ +# Grow Kit — zes verbeteringen + +Branch: `codex/grow-kit-six-improvements`. Elke slice krijgt een eigen commit. +Na een onderbreking: lees dit bestand, `git status`, `git log -8 --oneline`. + +## Volgorde en acceptatie +- [x] Slice 1 (advies 2): mens-wachtstatus blokkeert vervolgstappen; panic vóór elke stap/poging; onleesbare panic blokkeert; shell-bewijs vereist exitcode. Regressietests. +- [x] Slice 2 (advies 4): transactionele gebeurtenissen/opslag, behoud en import bestaande logs, crash/concurrentietests. +- [x] Slice 3 (advies 3): expliciete acceptatiecriteria en afzonderlijk technisch bewijs, inhoudelijk oordeel, menselijke goedkeuring. +- [x] Slice 4 (advies 1): één opdrachtpagina en compacte navigatie; bestaande hulpmiddelen blijven bereikbaar. +- [x] Slice 5 (advies 5): drie lokale voorbeeldopdrachten met plan, bevestiging, uitvoering en bewijs zonder VPS. +- [x] Slice 6 (advies 6): gegevensroute en verzonden inhoud zichtbaar; cloudtoestemming afdwingen; documentatie corrigeren. + +## Validatie +Voer gerichte regressietests per slice uit, daarna de volledige Python-suite en macOS-build indien beschikbaar. Geen externe agents/servers aanroepen tijdens tests. Leg fouten en beperkingen hier vast. + +## Stand +Repository opgehaald vanaf GitHub; werkboom schoon bij start. Graph-index aangemaakt (Verify): Users-tiendo-Projects-astra-vangrail-Grow-Kit. Eén bekende parse-gap: app/Sources/Koppelingen.swift:90; docs/scripts uitgesloten. Bronfallback waar nodig. + +### Slice 1 +39 gerichte tests groen; zes nieuwe regressietests eerst rood. Mens-wachtstappen zijn nu ratificeerbaar en stoppen de motor. PANIC blokkeert nieuwe commando’s en bewijscommando’s; lopende processen worden niet afgebroken (de UI moet dit expliciet tonen). Bestaande review-ok/bulk-ratificatie blijft behouden. Volledige suite gestart, resultaat volgt. + +### Slice 2 +69 gerichte tests groen. JSON-compatibiliteit behouden via flock + tempbestand/fsync/atomic replace/map-fsync; append-only mutaties weigeren historische wijzigingen. Motor, panic, ratificatie, mijlpalen, taak- en boomgebeurtenissen gebruiken gedeelde opslag. Automatiek bewaart plannen + gebeurtenissen in één transactionele store met legacy-import en JSON-exports; revisies voorkomen stale updates. Concurrentietest met vier processen bewaart alle 60 gebeurtenissen. Volledige suite signaleerde oude tests die een mens-pauze nog als succes verwachten, plus ontbrekende cryptography en sandbox/gebruikersmap-afhankelijkheden; integratie-aanpassingen volgen. + +### Slice 3 +12 tests groen. Bewijsrapport projecteert acceptatiecriteria en drie afzonderlijke oordelen per stap; technische checks geven geen inhoudelijke of menselijke goedkeuring. JSON-bewijs kan exacte veldwaarden/type controleren. Adaptercommando bewijsrapport beschikbaar; taakpagina in slice 4 gebruikt dezelfde projectie. + +### Slice 4 +4 gerichte tests groen (dossier van concept tot goedkeuring, wachten en hervatten, gelijktijdige uitvoering geweigerd, geen pad-ontsnapping via het id). Zijbalk: 00 Vandaag, 01 Opdrachten, 02 Bibliotheek, de rest onder Gereedschappen — nummering strikt oplopend, geen dubbele nummers meer. HomeView is opgegaan in het Vandaag-scherm (begroeting met ZT-3-variant, vier cijfers, knowledge graph) en daarna verwijderd: dat bestand was de enige echte buildbreker (`await MainActor.run` met een await erin). macOS-build groen met HomeView verwijderd. Let op: `opdrachten nieuw` werkt vandaag alleen met profiel tweede-brein; autonome-fabriek en dev-werkplaats hebben nog een leeg stappenplan (slice 5). + +### Pauze is geen fout (rechtzetting van slice 1) +Slice 1 liet een mens-moment de motor stoppen — goed — maar de adapter las die stop als motor-faal (exit 2). Een pauze werd zo als fout gemeld en zes bestaande tests werden rood. Nu benoemt `uitkomst()` de uitkomst (geslaagd | wacht_op_mens | gepauzeerd | gefaald) en `machine_deel_voltooid()` of alleen nog een mens-stap open is. Adapter, loop.py en seed.py: pauze → exit 0 met status wacht_op_mens en, als de machine-kant af is, wordt de boom volmaakt en geregistreerd; PANIC → eigen melding; een echt gefaalde stap houdt exit 2. 4 nieuwe guardtests; volledige suite 794 groen (was 790 met 6 rood). + +### Slice 5 +Drie voorbeeldopdrachten, elk volledig lokaal (geen VPS, geen netwerk, geen sleutel): `projectcontrole`, `documentenoverzicht`, `terugkerend-rapport`. Elk profiel draagt zijn eigen `voorbeeld`-blok (titel, uitleg, criteria) — één bron, dus de lijst in de app kan niet losraken van het plan dat draait. De voorbeelden staan op status `voorbeeld`, niet `bewezen-vorm`, zodat de profielenlijst eerlijk blijft. Adapteractie `opdrachten actie=voorbeelden`; het scherm toont de drie onder OPDRACHTEN (links). Eén bevestiging volstaat nu als eindresultaat: keur je de laatste mens-stap goed en is er daarna niets meer te draaien, dan is de opdracht `goedgekeurd` (met een acceptatie-entry in het logboek) in plaats van een tweede herstart-ronde. 8 nieuwe tests: contract (drie voorbeelden, plan, mens-stap, bekend bewijstype, geen externe aanroepen), echte uitvoering van alle drie met de beloofde bestanden, afwijzen → herziening_nodig, en de adapteractie. Volledige suite 802 groen; macOS-build groen. + +### Slice 6 +`kern/growkit_route.py` leidt per plan af wat de machine verlaat (lokaal · eigen_vps · cloud) op basis van de commando's, met de verklaring van het profiel als bron van waarheid — verklaart een profiel minder dan zijn commando's doen, dan wint het zwaarste en komt er een waarschuwing. Elk dossier toont de route, de uitleg en (uitklapbaar) de regels die naar buiten zouden gaan. Cloud vraagt expliciete toestemming: `opdrachten.toestemming(id, akkoord, reden)` legt het besluit vast in de geschiedenis (intrekken net zo zichtbaar), `uitvoeren` weigert zonder toestemming, en de app houdt de uitvoerknop dicht met een invulveld voor de reden. Alle bestaande profielen verklaren `lokaal`; de drie voorbeelden hebben `demo: true` → kosten € 0 in plaats van "niet gemeten". README gecorrigeerd: tests-badge 701 → 802, privacy-badge "100% local" → "lokaal eerst" met een link naar de nieuwe sectie **Wat verlaat je machine?**, de schermentabel naar de nieuwe nummering (00 Vandaag · 01 Opdrachten · 02 Bibliotheek + Gereedschappen), de quickstart met de één-minuut-route naar een voorbeeldopdracht, en de tellingen (54 kernmodules, 74 adaptercommando's, 802 tests, 13 E2E-scripts). 12 nieuwe tests. Volledige suite 814 groen; macOS-build groen. diff --git a/README.md b/README.md index 3b98c7a..e867071 100644 --- a/README.md +++ b/README.md @@ -4,9 +4,9 @@ [![License: MIT](https://img.shields.io/badge/license-MIT-blue?style=flat-square)](LICENSE) [![Platform](https://img.shields.io/badge/platform-macOS_14%2B-black?style=flat-square)]() [![Python](https://img.shields.io/badge/python-3.12%2B-blue?style=flat-square)]() -[![Tests](https://img.shields.io/badge/tests-701_groen-success?style=flat-square)]() +[![Tests](https://img.shields.io/badge/tests-799_in_CI-success?style=flat-square)]() [![Agents](https://img.shields.io/badge/agent-familie-7_teal?style=flat-square)]() -[![Privacy](https://img.shields.io/badge/privacy-100%25_local-success?style=flat-square)]() +[![Privacy](https://img.shields.io/badge/privacy-lokaal_eerst-success?style=flat-square)](#wat-verlaat-je-machine) [![Made by](https://img.shields.io/badge/build_in_public-Ti%C3%ABndo-9cf?style=flat-square)]() [![Encryption](https://img.shields.io/badge/secrets-AES--256_GCM-orange?style=flat-square)]() [![X](https://img.shields.io/badge/X-@GrowKitHarnas-black?style=flat-square)](https://x.com/GrowKitHarnas) @@ -34,35 +34,41 @@ Grow Kit is MIT-opensource. De motor en de vijf bewijscontroles blijven altijd g ## De app -Native macOS-app (SwiftUI) in editorial-monochrome stijl. Zijmenu: +Native macOS-app (SwiftUI) in editorial-monochrome stijl. De zijbalk begint met de +drie hoofdingangen — **00 Vandaag**, **01 Opdrachten**, **02 Bibliotheek** — en al +het gereedschap daaronder zit onder één uitklapper *Gereedschappen*. | Nr. | Scherm | Wat het doet | |---|---|---| -| 00 | Thuis | Dashboard, mini-graaf, saldo | -| **WERK** | | | -| 01 | Agent Chat | Praat met de familie; Thought-blok per antwoord, gesprek wissen (→archief), geschiedenis | -| 02 | Status | Identiteit, register, tellers, logboek | -| 03 | Planten | Kiemkeuze → concept → motor met bewijs | -| 04 | Goedkeuringen | Ratificatie: mens keurt goed of af | -| 05 | Dialoog | Scope-poort, prompt-slijper, ronde tafel | -| 06 | Agenten | Gouverneur: familie, observaties, taak-contracten | -| 07 | **Automatiek** | Eén zin in, automation-plan uit — KairOS stelt voor, jij keurt | -| 08 | Knowledge Graph | Brein-verbanden; klik op een sectie om in te zoeken | -| 09 | Prompts | Gecureerde bibliotheek, variabelen invullen | -| 10 | Vangnet | Opgevangen review-aanroepen en uitkomsten | -| 11 | Audit | Volledig, append-only logboek | -| **SYSTEEM** | | | -| 12 | Secure Vault | Echte kluizen via macOS hdiutil (AES-256/APFS) | -| 13 | Amnesia Protocol | Gevoelige tekst anonimiseren en herstellen | -| 14 | Digitale Kloon | Persoonlijke kluis: 6 categorieën, AES-256-GCM, PIN + Touch ID | -| 16 | Hervatten | Crash-herstel uit het logboek | -| 17 | Taak | Boom-pad + governor → takenlijst met bewijs | -| **LEREN** | | | -| 18 | **Telegram Connect** | De familie koppelen aan jouw eigen Telegram, stap voor stap | -| 19 | **CyberSeed** | Zes niveaus (Sprout → Amazone), lokaal (Ollama) of frontier-cloud (OpenRouter), eigen SOUL | -| 20 | Rondleiding | Het ontwerp in vijf schermen | -| 21 | Uitleg | De motor uitgelegd | -| 22 | Best Practices | Kerninzichten uit eigen onderzoek, met zoeken | +| 00 | **Vandaag** | Begroeting, de vier cijfers (familie, saldo, wacht op jou, geschiedenis) en de knowledge graph | +| 01 | **Opdrachten** | Eén dossier per opdracht: plan, grenzen, uitvoering, bewijs, jouw oordeel — met drie lokale voorbeelden | +| 02 | **Bibliotheek** | Gecureerde audit-prompts, letterlijk en alleen-lezen | +| **Gereedschappen** | | | +| 03 | Agent Chat | Praat met de familie; Thought-blok per antwoord, gesprek wissen (→archief), geschiedenis | +| 04 | Status | Identiteit, register, tellers, logboek | +| 05 | Planten | Kiemkeuze → concept → motor met bewijs | +| 06 | Goedkeuringen | Ratificatie: mens keurt goed of af | +| 07 | Dialoog | Scope-poort, prompt-slijper, ronde tafel | +| 08 | Agenten | Gouverneur: familie, observaties, taak-contracten | +| 09 | **Automatiek** | Eén zin in, automation-plan uit — KairOS stelt voor, jij keurt | +| 10 | Knowledge Graph | Brein-verbanden; klik op een sectie om in te zoeken | +| 11 | Vangnet | Opgevangen review-aanroepen en uitkomsten | +| 12 | Audit | Volledig, append-only logboek | +| 13 | Agenda | Cron, wachtende goedkeuringen en taken | +| 14 | Secure Vault | Echte kluizen via macOS hdiutil (AES-256/APFS) | +| 15 | Amnesia Protocol | Gevoelige tekst anonimiseren en herstellen | +| 16 | Digitale Kloon | Persoonlijke kluis: 6 categorieën, AES-256-GCM, PIN + Touch ID | +| 17 | Hervatten | Crash-herstel uit het logboek | +| 18 | Taak | Boom-pad + governor → takenlijst met bewijs | +| 19 | **Telegram Connect** | De familie koppelen aan jouw eigen Telegram, stap voor stap | +| 20 | **CyberSeed** | Zes niveaus (Sprout → Amazone), lokaal (Ollama) of frontier-cloud (OpenRouter), eigen SOUL | +| 21 | Skills | Welke skills draaien er op jouw GrowKit? | +| 25 | Rondleiding | Het ontwerp in vijf schermen | +| 26 | Uitleg | De motor uitgelegd | +| 27 | Best Practices | Kerninzichten uit eigen onderzoek, met zoeken | + +Instellingen staat permanent onderaan de zijbalk. De nummers 22–24 zijn +voorbereide schermen (browser, IDE, connectors) die nog niet in het menu staan. ## De agent-familie @@ -84,8 +90,12 @@ De agents kennen de gebruiker bij naam (het `van`-veld in elk chatbericht) en sp Voor wie verder wil kijken: -- **Python-kern** (`kern/`, 32 modules): scope-poort, stappen-motor met faalcontract, vijf machine-controles, review-laag, ratificatie, leesroute, crash-herstel, boom-register, vangnet (SQLite), agent-familie, Knowledge Graph, prompt-bibliotheek, Secure Vault (hdiutil), Amnesia (anonimiseren), Digitale Kloon (AES-256-GCM via `cryptography` in een repo-eigen `.venv` — bewuste uitzondering op stdlib-only), Best Practices. -- **Adapter** (`adapter.py`): JSON-CLI met 64 commando's over de kern — de enige poort tussen app en motor. +- **Python-kern** (`kern/`, 54 modules): scope-poort, stappen-motor met faalcontract, vijf machine-controles, review-laag, ratificatie, leesroute, crash-herstel, boom-register, vangnet (SQLite), agent-familie, Knowledge Graph, prompt-bibliotheek, Secure Vault (hdiutil), Amnesia (anonimiseren), Digitale Kloon (AES-256-GCM via `cryptography` in een repo-eigen `.venv` — bewuste uitzondering op stdlib-only), Best Practices. +- **Adapter** (`adapter.py`): JSON-CLI met 74 commando's over de kern — de enige poort tussen app en motor. +- **Opdrachtdossier** (`kern/growkit_opdrachten.py`): één blijvend dossier per opdracht — bevestigd plan met `plan_hash`, uitvoerslot tegen dubbel draaien, wachtende mens-stappen, oordeel en PANIC-herstel. Transactionele opslag (`kern/growkit_opslag.py`: flock + atomair schrijven). +- **Pauze is geen fout** (`kern/growkit_motor.py`): `uitkomst()` benoemt wat een run deed (geslaagd · wacht_op_mens · gepauzeerd · gefaald) en `machine_deel_voltooid()` zegt of alleen nog jouw besluit openstaat. Een mens-moment levert exit 0 met status `wacht_op_mens`; een echt falen houdt exit 2. +- **Gegevensroute** (`kern/growkit_route.py`): leidt per plan af of er iets de machine verlaat (lokaal · eigen VPS · cloud). Een profiel mag het zelf verklaren; verklaart het minder dan zijn commando's doen, dan wint het zwaarste en verschijnt er een waarschuwing. Cloud vraagt om expliciete toestemming — zonder die toestemming start de opdracht niet. +- **Voorbeelden** (`kern/growkit_voorbeelden.py` + `profielen/`): drie lokale voorbeeldopdrachten (projectcontrole, documentenoverzicht, terugkerend rapport), elk met een eigen plan, sjablonen en een mens-stap. Eén bron: het profiel draagt zijn eigen voorbeeld-blok. - **CyberSeed** (`kern/growkit_cyberseed.py` + `kern/growkit_ram.py`): zes modelniveaus — Sprout v0.5, Root v1.0, Leaf v1.5, Tree v2.0, Jungle v2.5, Amazone v3.0 — elk met een eigen systeemprompt op autonomie-schaal (governance in alle tiers). Per niveau kies je **lokaal** (Ollama, RAM-klasse bepaalt het model; te zware namen zijn vergrendeld met min-RAM-uitleg) of **cloud** (OpenRouter, frontier-opties per naam). Zelfbijgewerkte SOUL-snapshot uit GrowKit-data; routinglog per aanroep; chatlog append-only; wissen alleen met `bevestig=true`. Eigen OpenRouter-model per naam mogelijk mét tier-validatie (±1 niveau, `force=true` voor bewuste keuze). Lokaal is de eindbestemming — cloud is de brug. Niets verlaat de Mac bij lokaal. ### CyberSeed: de zes niveaus @@ -114,7 +124,7 @@ Voor wie verder wil kijken: git clone git@github.com:parvenuprompting/Grow-Kit.git cd Grow-Kit python3 -m venv .venv && .venv/bin/pip install cryptography -.venv/bin/python -m unittest discover tests # 546 tests +.venv/bin/python -m unittest discover tests # 802 tests python3 seed.py # geleende-agent-modus: kiemkeuze + planten python3 loop.py # het harnas: planten / hervatten / taak / ratificatie / status @@ -127,6 +137,19 @@ python3 loop.py # het harnas: planten / hervatten / taak / ratificati - VPS-verbinding: `export GROWKIT_HOST=gebruiker@jouw-vps` of zet het in `.env`. - Verdere uitleg: `SEED.md` → `profielen/INDEX.md` → **`docs/HOE-HET-WERKT.md`**. +### Je eerste opdracht (één minuut) + +1. Open de app → **00 Vandaag**. +2. Kies links onder **VOORBEELDEN** één van de drie: *Projectcontrole*, + *Documentenoverzicht* of *Terugkerend rapport*. +3. Je ziet het plan, de afgesproken grenzen en de gegevensroute — er draait nog niets. +4. Bevestig: de machine doet de stappen en legt per stap bewijs vast. +5. De opdracht pauzeert bij het mens-moment. Lees het resultaat, geef je reden en + keur goed of wijs af. + +De drie voorbeelden werken **zonder VPS, zonder sleutel en zonder internet**: ze +tellen en controleren alleen bestanden op jouw machine. + ## Structuur ``` @@ -134,12 +157,12 @@ Grow-Kit/ ├── SEED.md ← geboortebrief ├── seed.py ← plant-mechanisme ├── loop.py ← het harnas: orchestratie zonder agent -├── adapter.py ← JSON-CLI brug (61 commando's) -├── kern/ ← 32 modules +├── adapter.py ← JSON-CLI brug (74 commando's) +├── kern/ ← 54 modules ├── profielen/ ← bomen: JSON-stappenplannen met gecodeerd bewijs ├── groei/ ← groeilaag-instructie -├── tests/ ← 701 tests + 20 E2E-scripts -├── app/ ← macOS SwiftUI-app (22 views) +├── tests/ ← 802 tests + 13 E2E-scripts +├── app/ ← macOS SwiftUI-app │ ├── Sources/ ← views + Thema/Bouwstenen │ ├── Fonts/ ← Fraunces + Inter (SIL OFL) │ └── build.sh ← XcodeGen + xcodebuild @@ -157,11 +180,38 @@ Elke push en PR draait automatisch **CI** (GitHub Actions): 2. **Secrets-scan** — dezelfde key-patronen als het taak-contract, over elke diff; een echte key blokkeert de push 3. **macOS-build** — GrowKit.app moet compileren met fonts ingebed (op main) -- **701 tests groen** (unittest; de enige externe dependency is `cryptography` voor de Digitale Kloon, in een repo-eigen `.venv` — bewuste, gedocumenteerde keuze) -- **20 end-to-end-scripts**: fase-testen + slice-E2E +- **799 in CI (Linux); 818 op macOS — 19 Digitale-Kloon-tests vereisen de macOS Keychain.** (unittest; de enige externe dependency is `cryptography` voor de Digitale Kloon, in een repo-eigen `.venv` — bewuste, gedocumenteerde keuze) +- **13 end-to-end-scripts**: fase-testen + slice-E2E - Test 4 bewijst agent-onafhankelijkheid: harnas plant, crasht (`kill -9`), hervat en ratificeert — met alleen python3 - Elke nieuwe slice TDD: eerst rood, dan groen, dan end-to-end +## Wat verlaat je machine? + +Grow Kit is **lokaal-eerst**, en dat is een belofte die je per opdracht kunt +controleren in plaats van op een badge te vertrouwen. Elke opdracht toont vóór het +draaien zijn **gegevensroute**: + +| Route | Wat het betekent | +|---|---| +| **Lokaal** | Alles gebeurt op jouw machine. Geen sleutel, geen verbinding nodig. | +| **Eigen VPS** | Er gaat iets naar je eigen server (`GROWKIT_HOST`) — niets daarbuiten. | +| **Cloud** | Er gaat inhoud naar een clouddienst buiten je eigen systemen. | + +De route wordt afgeleid uit de commando's van het plan (`ssh`/`scp` → eigen VPS, +`curl`/`wget`/`http(s)` → cloud). Verklaart een profiel mínder dan zijn commando's +doen, dan wint het zwaarste en verschijnt er een waarschuwing — geen stille keuze. + +**Cloud start nooit vanzelf.** Is de route cloud, dan blijft de uitvoerknop dicht +tot je met een reden toestemming geeft. Dat besluit landt in de geschiedenis en is +net zo zichtbaar in te trekken. De motor weigert de uitvoering ook als een script +het zonder toestemming probeert. + +Eerlijk over de rest van het huis: **Agent Chat** loopt via je eigen VPS, +**CyberSeed** kiest per niveau lokaal (Ollama) of cloud (OpenRouter) — die keuze +maak jij, en op een 24 GB Mac zijn alle zes niveaus lokaal beschikbaar. De drie +voorbeeldopdrachten, de motor, de vijf bewijscontroles en de opslag zijn volledig +lokaal, kosten € 0 en hebben geen sleutel nodig. + ## Filosofie Grow Kit gaat ervan uit dat de AI fouten maakt — **zero-trust**. De interpretatie van "is het gelukt?" ligt nooit bij het model, maar bij een deterministische controlelaag. diff --git a/adapter.py b/adapter.py index ed743a6..3a3a913 100644 --- a/adapter.py +++ b/adapter.py @@ -11,6 +11,7 @@ - Fouten: {"ok": false, "fout": ""} met exit 1 — nooit een traceback. - Stateless: geen sessie-staat tussen aanroepen. """ +from kern.growkit_opslag import voeg_gebeurtenissen_toe import json import re from datetime import datetime, timezone @@ -103,16 +104,24 @@ def cmd_hervat(invoer: dict) -> dict: geslaagd = growkit_motor.voer_uit({**profiel, "stappen": restdraai}, doel, logboek, Path(__file__).parent / "profielen" / naam / "sjablonen", reviewconfig=reviewconfig) - if geslaagd: + stop = None if geslaagd else growkit_motor.uitkomst(logboek) + # Ook hier: een pauze vóór de mens is geen faal. Is de machine-kant van + # het hele plan af, dan mag de boom volmaakt worden. + if geslaagd or (stop == "wacht_op_mens" + and growkit_motor.machine_deel_voltooid(profiel, logboek)): growkit_oerwoud.volmaak_na_plant(doel, logboek) stappen = [{"id": e["stap"], "status": e["status"], "bewijs": e["bewijs"], "review_rol": e.get("review_rol"), "review_oordeel": e.get("review_oordeel")} for e in json.loads(logboek.read_text(encoding="utf-8")) if e.get("stap", "").startswith("stap-")] - if not geslaagd: + if not geslaagd and stop != "wacht_op_mens": + if stop == "gepauzeerd": + raise AdapterFaal("PANIC actief — er starten geen nieuwe commando's; " + "herstel handmatig", stappen) raise AdapterFaal("restdraai faalde na alternatief — roep de mens", stappen) return {"ok": True, "data": {"stappen": stappen, - "herstartpunt": resultaat["herstartpunt"]}} + "herstartpunt": resultaat["herstartpunt"], + "status": "geslaagd" if geslaagd else "wacht_op_mens"}} def cmd_taak(invoer: dict) -> dict: @@ -165,7 +174,13 @@ def cmd_profielen(invoer: dict) -> dict: class AdapterFaal(Exception): - """Motor-faal: {"ok": false, "fout", "stappen"} met exit 2 (faalcontract).""" + """Motor-faal: {"ok": false, "fout", "stappen"} met exit 2 (faalcontract). + + Alleen voor echt falen (een stap mislukt na zijn alternatief) en voor PANIC. + Een pauze vóór de mens (wacht_op_mens) is géén faal: die komt terug als + {"ok": true, ..., "status": "wacht_op_mens"} met exit 0 — de motor stopte + omdat jij moet beslissen, niet omdat er iets stuk is. + """ def __init__(self, fout: str, stappen: list[dict]): super().__init__(fout) @@ -238,12 +253,16 @@ def cmd_plant(invoer: dict) -> dict: doel.mkdir(parents=True, exist_ok=True) logboek = doel / "logboek.json" if not logboek.exists(): - logboek.write_text("[]", encoding="utf-8") + voeg_gebeurtenissen_toe(logboek, []) profiel = growkit_motor.vervang_growkit_pad(profiel, REPO) geslaagd = growkit_motor.voer_uit(profiel, doel, logboek, Path(__file__).parent / "profielen" / naam / "sjablonen", reviewconfig=reviewconfig) - if geslaagd: + stop = None if geslaagd else growkit_motor.uitkomst(logboek) + # Pauze is geen fout: is de machine-kant af, dan is de boom klaar en wacht + # alleen jouw bevestiging (een mens-stap aan het eind van het plan). + if geslaagd or (stop == "wacht_op_mens" + and growkit_motor.machine_deel_voltooid(profiel, logboek)): growkit_oerwoud.volmaak_na_plant(doel, logboek) if brein_pad: try: @@ -255,10 +274,14 @@ def cmd_plant(invoer: dict) -> dict: "review_rol": e.get("review_rol"), "review_oordeel": e.get("review_oordeel")} for e in json.loads(logboek.read_text(encoding="utf-8")) if e.get("stap", "").startswith("stap-")] - if not geslaagd: + if not geslaagd and stop != "wacht_op_mens": + if stop == "gepauzeerd": + raise AdapterFaal("PANIC actief — er starten geen nieuwe commando's; " + "herstel handmatig", stappen) raise AdapterFaal("motor-faal na alternatief — roep de mens", stappen) return {"ok": True, "data": {"stappen": stappen, "registratie": registratie, - "brein_pad": str(brein_pad) if brein_pad else None}} + "brein_pad": str(brein_pad) if brein_pad else None, + "status": "geslaagd" if geslaagd else "wacht_op_mens"}} def cmd_ratificeer(invoer: dict) -> dict: @@ -1645,7 +1668,59 @@ def cmd_panic_status(invoer: dict) -> dict: "actief": growkit_panic.is_panic_actief(doel)} +def cmd_opdrachten(invoer: dict) -> dict: + import contextlib + from kern import growkit_opdrachten as opdrachten + from kern.growkit_motor import vervang_growkit_pad + actie = invoer.get("actie", "lijst") + try: + with contextlib.redirect_stdout(sys.stderr): + if actie == "lijst": + data = opdrachten.lijst() + elif actie == "nieuw": + naam = str(invoer.get("profiel", "")) + profiel = vervang_growkit_pad(_laad_profiel(naam), REPO) + data = opdrachten.nieuw(str(invoer.get("titel", "")), invoer.get("criteria", []), + profiel, REPO / "profielen" / naam / "sjablonen") + elif actie == "lees": + data = opdrachten.lees(invoer.get("id")) + elif actie == "uitvoeren": + data = opdrachten.uitvoeren(invoer.get("id"), invoer.get("plan_hash"), invoer.get("bevestig")) + elif actie == "beoordeel": + data = opdrachten.beoordeel(invoer.get("id"), invoer.get("goedgekeurd"), str(invoer.get("toelichting", ""))) + elif actie == "voorbeelden": + from kern import growkit_voorbeelden + data = {"voorbeelden": growkit_voorbeelden.voorbeelden()} + elif actie == "toestemming": + data = opdrachten.toestemming(invoer.get("id"), invoer.get("akkoord"), + str(invoer.get("toelichting", ""))) + elif actie in ("panic", "herstel"): + data = opdrachten.panic(invoer.get("id"), herstel=actie == "herstel") + else: + raise ValueError("Onbekende opdrachtactie") + except (ValueError, OSError, KeyError, TypeError, AttributeError) as e: + raise AdapterFout(str(e)) from e + return {"ok": True, "data": data} + + +def cmd_bewijsrapport(invoer: dict) -> dict: + from kern.growkit_resultaat import bewijsrapport + doel = _doel_uit(invoer) + naam = str(invoer.get("profiel", "")).strip() + if not naam: + raise AdapterFout("profiel is verplicht voor een bewijsrapport") + log = doel / "logboek.json" + try: + entries = json.loads(log.read_text()) if log.exists() else [] + rapport = bewijsrapport(_laad_profiel(naam), entries) + except (ValueError, OSError) as e: + raise AdapterFout(f"Bewijsrapport niet leesbaar: {e}") from e + return {"ok": True, "data": rapport} + + COMMANDOS = { + "opdrachten": cmd_opdrachten, + "bewijsrapport": cmd_bewijsrapport, "status": cmd_status, "profielen": cmd_profielen, "plant": cmd_plant, diff --git a/app/Sources/ContentView.swift b/app/Sources/ContentView.swift index c4ac42a..95e56e8 100644 --- a/app/Sources/ContentView.swift +++ b/app/Sources/ContentView.swift @@ -26,42 +26,47 @@ struct ContentView: View { case agentchat = 100, skills, browser, ide, connectors case graaf = 110 case prompts = 120 + case opdrachten = 130 var id: Int { rawValue } var nummer: String { + // Strikt oplopend: 00–02 zijn de hoofdingangen, 03+ zit onder + // "Gereedschappen". Eén nummer per modus, geen dubbele. switch self { case .home: return "00" - case .agentchat: return "01" - case .status: return "02" - case .planten: return "03" - case .goedkeuringen: return "04" - case .dialoog: return "05" - case .agenten: return "06" - case .automatiek: return "07" - case .graaf: return "08" - case .prompts: return "09" - case .vangnet: return "10" - case .audit: return "11" - case .agenda: return "12" - case .securevault: return "13" - case .amnesia: return "14" - case .kloon: return "15" - case .hervatten: return "16" - case .taak: return "17" - case .rondleiding: return "20" - case .uitleg: return "21" - case .gids: return "22" - case .telegram: return "18" - case .cyberseed: return "19" - case .skills: return "15" - case .browser: return "16" - case .ide: return "17" - case .connectors: return "18" + case .opdrachten: return "01" + case .prompts: return "02" + case .agentchat: return "03" + case .status: return "04" + case .planten: return "05" + case .goedkeuringen: return "06" + case .dialoog: return "07" + case .agenten: return "08" + case .automatiek: return "09" + case .graaf: return "10" + case .vangnet: return "11" + case .audit: return "12" + case .agenda: return "13" + case .securevault: return "14" + case .amnesia: return "15" + case .kloon: return "16" + case .hervatten: return "17" + case .taak: return "18" + case .telegram: return "19" + case .cyberseed: return "20" + case .skills: return "21" + case .browser: return "22" + case .ide: return "23" + case .connectors: return "24" + case .rondleiding: return "25" + case .uitleg: return "26" + case .gids: return "27" } } var naam: String { switch self { - case .home: return "Thuis" + case .opdrachten: return "Opdrachten" + case .home: return "Vandaag" case .rondleiding: return "Rondleiding" case .uitleg: return "Uitleg" case .gids: return "Best Practices" @@ -87,12 +92,13 @@ struct ContentView: View { case .ide: return "IDE" case .connectors: return "Connectors" case .graaf: return "Knowledge Graph" - case .prompts: return "Prompts" + case .prompts: return "Bibliotheek" } } var beschrijving: String { switch self { - case .home: return "Startpunten en de dialoog binnen handbereik" + case .opdrachten: return "Plan, uitvoering, bewijs en resultaat op één plek" + case .home: return "Opdrachten en besluiten voor vandaag" case .rondleiding: return "De vijf schermen van het ontwerp" case .uitleg: return "Zes regels · de engine room" case .gids: return "Kerninzichten uit je eigen documenten" @@ -193,34 +199,15 @@ struct ContentView: View { // ook op een klein venster. ScrollView { VStack(alignment: .leading, spacing: 0) { - // THUIS — de landingspagina, altijd bereikbaar - ForEach([Modi.home]) { modus in + ForEach([Modi.home, .opdrachten, .prompts]) { modus in modusRij(modus) } + DisclosureGroup("Gereedschappen") { + ForEach([Modi.agentchat, .status, .planten, .goedkeuringen, .dialoog, .agenten, .automatiek, .graaf, .vangnet, .audit, .agenda, .securevault, .amnesia, .kloon, .hervatten, .taak, .telegram, .cyberseed, .skills, .rondleiding, .uitleg, .gids]) { modus in + modusRij(modus) + } + }.padding(.top, 16) - Rectangle().fill(Thema.kleur(.lijn)).frame(height: 1) - - // WERK — Agent Chat eerst (hoofdfunctie), daarna de dagelijkse modi - zijbalkSectie("WERK") - ForEach([Modi.agentchat, .status, .planten, .goedkeuringen, .dialoog, .agenten, .automatiek, .graaf, .prompts, .vangnet, .audit, .agenda]) { modus in - modusRij(modus) - } - - Rectangle().fill(Thema.kleur(.lijn)).frame(height: 1) - - // SYSTEEM — Secure Vault eerst (privacy-fundering), dan herstel en taken - zijbalkSectie("SYSTEEM") - ForEach([Modi.securevault, .amnesia, .kloon, .hervatten, .taak]) { modus in - modusRij(modus) - } - - Rectangle().fill(Thema.kleur(.lijn)).frame(height: 1) - - // LEREN — rondleiding, uitleg en de AI Gids - zijbalkSectie("LEREN") - ForEach([Modi.telegram, .cyberseed, .rondleiding, .uitleg, .gids]) { modus in - modusRij(modus) - } } } .scrollIndicators(.automatic) @@ -398,8 +385,14 @@ struct ContentView: View { case .agenda: AgendaView(runner: runner, repoPad: $repoPad, interpreter: $interpreter) case .home: - HomeView(runner: runner, koppelingen: koppelingen, - repoPad: $repoPad, interpreter: $interpreter) { modus in + // "Vandaag" is het dagoverzicht bovenop het opdrachtendossier + // (voorheen HomeView — dat bestand is opgegaan in dit scherm). + OpdrachtenView(runner: runner, repoPad: $repoPad, interpreter: $interpreter, + vandaag: true) { modus in + geselecteerd = modus + } + case .opdrachten: + OpdrachtenView(runner: runner, repoPad: $repoPad, interpreter: $interpreter) { modus in geselecteerd = modus } case .rondleiding: diff --git a/app/Sources/HomeView.swift b/app/Sources/HomeView.swift deleted file mode 100644 index c8a91e9..0000000 --- a/app/Sources/HomeView.swift +++ /dev/null @@ -1,230 +0,0 @@ -// Homescherm — de rustige landingspagina: wat is GrowKit, en een klein -// dashboard met de info die overzichtelijk bij de hand moet zijn. -// Minimalistisch bij de les: één blik, één klik, aan het werk. - -import SwiftUI - -struct HomeView: View { - @ObservedObject var runner: Runner - @ObservedObject var koppelingen: KoppelingenStore - @Binding var repoPad: String - @Binding var interpreter: String - var onNavigeer: (ContentView.Modi) -> Void - - @State private var familie: [[String: Any]] = [] - @State private var leeft: [String: String] = [:] - @State private var saldoTekst: String = "" - @State private var saldoLaag: Bool = false - @State private var gebruikersNaam: String = "Gebruiker" - @State private var heroTekst: String = "" - - var body: some View { - ScrollView { - VStack(alignment: .leading, spacing: 22) { - kop - TipRotorView(tellers: [ - "planten": familie.count, - "taken": 0, - "saldo": saldoTekst.isEmpty ? 0 : 1, - ], onNavigeer: onNavigeer) - watIsGrowKit - dashboard - graafSectie - Spacer(minLength: 12) - } - .padding(28) - } - .background(Thema.kleur(.papier)) - .onAppear { laadDashboard() } - } - - // MARK: Kop — wie je bent, wat dit huis is - - private var kop: some View { - VStack(alignment: .leading, spacing: 5) { - Text("THUIS · LANDINGSPAGINA") - .font(Thema.tekst(10, gewicht: .semibold)).tracking(3) - .foregroundStyle(Thema.kleur(.zacht)) - HStack(alignment: .firstTextBaseline, spacing: 0) { - // ZT-3 dynamische hero: gebeurtenis-variant (goedkeuringen, - // saldo, nachtronde) wint van de kale dagdeel-begroeting. - Text((heroTekst.isEmpty ? begroetingTekst : heroTekst) + " ") - .font(Thema.display(30)) - if heroTekst.isEmpty { - Text(gebruikersNaam + ".").font(Thema.display(30, cursief: true)).foregroundStyle(Thema.kleur(.zacht)) - } - } - } - } - - // ZT-3: dagdeel-begroeting met nachtbug-afdekking (0-4 uur = morgen). - private var begroetingTekst: String { - let uur = Calendar.current.component(.hour, from: Date()) - switch uur { - case 0...11: return "Goedemorgen, \(gebruikersNaam)" - case 12...17: return "Goedemiddag, \(gebruikersNaam)" - default: return "Goedenavond, \(gebruikersNaam)" - } - } - - private var watIsGrowKit: some View { - VStack(alignment: .leading, spacing: 8) { - Text("GrowKit is jouw huis voor AI-agenten.").font(Thema.display(17)) - Text("Je plant bomen (projecten), de familie-agents voeren taken uit met machine-bewijs, en jij behoudt de laatste stem: elke belangrijke stap wacht op jouw goedkeuringen. Alles loopt via de adapter — de poort, motor en het faalcontract blijven de bewakers. Tests zijn wet; secrets blijven op de doelmachine; de geschiedenis is append-only.") - .font(Thema.tekst(12)).foregroundStyle(Thema.kleur(.zacht)) - .fixedSize(horizontal: false, vertical: true) - } - .padding(18) - .frame(maxWidth: .infinity, alignment: .leading) - .overlay(Rectangle().fill(Thema.kleur(.lijn)).frame(width: 2), alignment: .leading) - } - - // MARK: Klein dashboard — de vier dingen die je wilt zien - - private var dashboard: some View { - HStack(alignment: .top, spacing: 0) { - dashCel(titel: "FAMILIE", waarde: liveTeller, sub: "van \(familie.count) live") - verticaleLijn - dashCel(titel: "SALDO", waarde: saldoTekst.isEmpty ? "—" : saldoTekst, - sub: saldoLaag ? "onder €10 — bijvullen" : "OpenRouter", - rood: saldoLaag) - verticaleLijn - dashCel(titel: "HARNAS", waarde: "wet", sub: "kadertests verankerd") - verticaleLijn - dashCel(titel: "GESCHIEDENIS", waarde: "append-only", sub: "niets wordt gewist") - Spacer() - } - } - - private var liveTeller: String { - let actief = leeft.values.filter { $0 == "active" }.count - return familie.isEmpty ? "—" : "\(actief)" - } - - private var verticaleLijn: some View { - Rectangle().fill(Thema.kleur(.lijn)).frame(width: 1, height: 54) - } - - private func dashCel(titel: String, waarde: String, sub: String, rood: Bool = false) -> some View { - VStack(alignment: .leading, spacing: 3) { - Text(titel).font(Thema.tekst(8, gewicht: .semibold)).tracking(1.5) - .foregroundStyle(Thema.kleur(.gedempt)) - Text(waarde).font(Thema.display(22)) - .foregroundStyle(rood ? Color.red : Thema.kleur(.inkt)) - Text(sub).font(Thema.tekst(9)).foregroundStyle(Thema.kleur(.gedempt)) - } - .padding(.horizontal, 18) - } - - // MARK: Knowledge-graaf op de landing - - private var graafSectie: some View { - VStack(alignment: .leading, spacing: 10) { - HStack(alignment: .firstTextBaseline) { - Text("Knowledge Graph").font(Thema.display(20)) - Text("· het hele brein in één kaart — scroll, zoom, klik en lees") - .font(Thema.tekst(10)).foregroundStyle(Thema.kleur(.gedempt)) - Spacer() - Button("Openen") { onNavigeer(.graaf) } - .buttonStyle(.plain) - .font(Thema.tekst(11, gewicht: .medium)) - .foregroundStyle(Thema.kleur(.zacht)) - } - GraafView(runner: runner, repoPad: $repoPad, interpreter: $interpreter, - compactVoorbeeld: true) - .frame(height: 420) - .overlay(RoundedRectangle(cornerRadius: 4).stroke(Thema.kleur(.lijn))) - } - } - - // MARK: Startpunten (verplaatst naar de graaf en het zijmenu) - - private var startpunten: some View { - Kaart(kop: "Direct aan de slag") { - VStack(alignment: .leading, spacing: 0) { - startpunt("01", "Status", "De staat van je boom — identiteit, register, tellers", .status) - startpunt("02", "Nieuwe boom planten", "Kies een profiel, bekijk het concept, bevestig", .planten) - startpunt("03", "Goedkeuringen", "Wachtende mens-momenten in bulk beoordelen", .goedkeuringen) - startpunt("05", "Agenten", "De familie: taken, controle, observer", .agenten) - } - } - } - - private func startpunt(_ nummer: String, _ titel: String, - _ beschrijving: String, _ bestemming: ContentView.Modi) -> some View { - Button(action: { onNavigeer(bestemming) }) { - HStack(spacing: 14) { - Text(nummer).font(Thema.display(16, cursief: true)) - .foregroundStyle(Thema.kleur(.gedempt)) - .frame(width: 28, alignment: .leading) - VStack(alignment: .leading, spacing: 2) { - Text(titel).font(Thema.display(17)) - .foregroundStyle(Thema.kleur(.inkt)) - Text(beschrijving).font(Thema.tekst(11)) - .foregroundStyle(Thema.kleur(.zacht)) - } - Spacer() - Image(systemName: "arrow.right").font(.system(size: 12)) - .foregroundStyle(Thema.kleur(.gedempt)) - } - .padding(.vertical, 13) - .contentShape(Rectangle()) - } - .buttonStyle(.plain) - .overlay(alignment: .bottom) { Rectangle().fill(Thema.kleur(.lijn)).frame(height: 1) } - } - - // MARK: Data - - private func laadDashboard() { - Task { - let p = try? await runner.roep(repoPad: repoPad, interpreter: interpreter, - commando: "profiel", invoer: ["actie": "lees"]) - let f = try? await runner.roep(repoPad: repoPad, interpreter: interpreter, - commando: "familie", invoer: ["actie": "status"]) - let s = try? await runner.roep(repoPad: repoPad, interpreter: interpreter, - commando: "agentstatus", invoer: [:]) - let g = try? await runner.roep(repoPad: repoPad, interpreter: interpreter, - commando: "saldo", invoer: [:]) - await MainActor.run { - if let p, p.ok, let profiel = p.data["profiel"] as? [String: Any], - let naam = profiel["naam"] as? String, !naam.isEmpty { - gebruikersNaam = naam - } - if let f, f.ok, let fam = f.data["familie"] as? [[String: Any]] { - familie = fam - } - if let s, let agents = s.data["agents"] as? [[String: Any]] { - var kaart: [String: String] = [:] - for a in agents { - if let naam = a["agent"] as? String, let st = a["status"] as? String { - kaart[naam] = st - } - } - leeft = kaart - } - if let g, g.ok, let rest = g.data["resterend"] as? Double { - saldoTekst = String(format: "€ %.2f", rest) - saldoLaag = rest < 10.0 - } - // ZT-3: hero-variant op prioriteit — goedkeuringen > saldo > nachtronde. - var goedkeuringenAantal = 0 - if let ak = try? await runner.roep(repoPad: repoPad, interpreter: interpreter, - commando: "goedkeuringen", invoer: ["actie": "lijst"]), - ak.ok, let items = ak.data["items"] as? [[String: Any]] { - goedkeuringenAantal = items.count - } - let nachtrondeNieuws = false // nachtelijke bouwronde-koppeling volgt in een latere slice - let uur = Calendar.current.component(.hour, from: Date()) - let variant = ZTHero.variant(uur: uur, - goedkeuringen: goedkeuringenAantal, - saldo: saldoLaag ? 0 : 100, - saldoDrempel: 10, - nachtronde: nachtrondeNieuws) - if let v = variant { - heroTekst = ZTHero.tekstVoor(variant: v, goedkeuringen: goedkeuringenAantal) - } - } - } - } -} diff --git a/app/Sources/OpdrachtenView.swift b/app/Sources/OpdrachtenView.swift new file mode 100644 index 0000000..8cafeb8 --- /dev/null +++ b/app/Sources/OpdrachtenView.swift @@ -0,0 +1,460 @@ +import SwiftUI + +/// Eén dossier: de adapter bewaart het plan, voortgang, bewijs en oordeel. +/// In de stand "Vandaag" staat er bovendien het dagoverzicht dat eerder op +/// het thuisscherm stond: begroeting met de ZT-3-variant, vier cijfers in +/// één oogopslag en de knowledge graph. +struct OpdrachtenView: View { + @ObservedObject var runner: Runner + @Binding var repoPad: String + @Binding var interpreter: String + var vandaag = false + var onNavigeer: (ContentView.Modi) -> Void = { _ in } + @State private var opdrachten: [[String: Any]] = [] + @State private var profielen: [[String: Any]] = [] + @State private var dossier: [String: Any]? + @State private var titel = "" + @State private var criterium = "" + @State private var profiel = "" + @State private var toelichting = "" + @State private var fout: String? + @State private var bezig = false + @State private var nieuw = false + @State private var voorbeelden: [[String: Any]] = [] + // Dagoverzicht (verhuisd uit HomeView): alleen gevuld in de stand "Vandaag". + @State private var gebruikersNaam = "Gebruiker" + @State private var heroTekst = "" + @State private var familie: [[String: Any]] = [] + @State private var leeft: [String: String] = [:] + @State private var saldoTekst = "" + @State private var saldoLaag = false + @State private var wachtendeGoedkeuringen = 0 + + var body: some View { + VStack(alignment: .leading, spacing: 0) { + if vandaag { vandaagKop.padding(.horizontal, 28).padding(.top, 24) } + HStack(alignment: .top, spacing: 0) { + ScrollView { + VStack(alignment: .leading, spacing: 14) { + if vandaag { + Text("OPDRACHTEN").font(Thema.tekst(10, gewicht: .semibold)).tracking(3) + .foregroundStyle(Thema.kleur(.zacht)) + } else { + Text("Opdrachten").font(Thema.display(28)) + Text("Wat heeft jouw aandacht nodig?").foregroundStyle(.secondary) + } + Button("Nieuwe opdracht") { nieuw = true; dossier = nil } + Button("Verversen") { Task { await laad() } } + if opdrachten.isEmpty { + Text("Begin met één opdracht. Je bekijkt eerst het plan en beslist daarna of het mag draaien.") + .font(.callout).foregroundStyle(.secondary) + } + ForEach(opdrachten.indices, id: \.self) { i in + let item = opdrachten[i] + Button { + Task { await actie("lees", extra: ["id": item["id"] ?? ""]) } + } label: { + VStack(alignment: .leading, spacing: 4) { + Text(item["titel"] as? String ?? "Opdracht").fontWeight(.medium) + Text(label(item["status"] as? String ?? "")).font(.caption).foregroundStyle(.secondary) + }.frame(maxWidth: .infinity, alignment: .leading).padding(10) + }.buttonStyle(.bordered) + } + if !opdrachten.isEmpty { + Text("\(opdrachten.filter { ($0["status"] as? String) == "goedgekeurd" }.count) van \(opdrachten.count) opdrachten door jou goedgekeurd") + .font(.caption).foregroundStyle(.secondary) + } + voorbeeldLijst + }.padding(22) + }.frame(width: 280) + Divider() + ScrollView { + VStack(alignment: .leading, spacing: 20) { + if let dossier { detail(dossier) } + else { + formulier + if vandaag { graafBlok } + } + if let fout { Text(fout).foregroundStyle(.red).textSelection(.enabled) } + if bezig { ProgressView("Bezig — voortgang wordt bewaard") } + }.padding(28).frame(maxWidth: .infinity, alignment: .leading) + } + } + } + .background(Thema.kleur(.papier)) + .task { await laad() } + } + + // MARK: - Dagoverzicht ("Vandaag") + + private var vandaagKop: some View { + VStack(alignment: .leading, spacing: 16) { + VStack(alignment: .leading, spacing: 5) { + Text("VANDAAG").font(Thema.tekst(10, gewicht: .semibold)).tracking(3) + .foregroundStyle(Thema.kleur(.zacht)) + HStack(alignment: .firstTextBaseline, spacing: 0) { + // ZT-3: gebeurtenis-variant (goedkeuringen, saldo, nachtronde) + // wint van de kale dagdeel-begroeting. + Text((heroTekst.isEmpty ? begroeting : heroTekst) + " ") + .font(Thema.display(30)) + if heroTekst.isEmpty { + Text(gebruikersNaam + ".").font(Thema.display(30, cursief: true)) + .foregroundStyle(Thema.kleur(.zacht)) + } + } + } + dagrapport + if wachtendeGoedkeuringen > 0 { + Button("Bekijk de wachtende goedkeuringen") { onNavigeer(.goedkeuringen) } + .buttonStyle(.plain).font(Thema.tekst(11, gewicht: .medium)) + .foregroundStyle(Thema.kleur(.zacht)) + } + TipRotorView(tellers: [ + "planten": familie.count, + "taken": 0, + "saldo": saldoTekst.isEmpty ? 0 : 1, + ], onNavigeer: onNavigeer) + } + } + + private var begroeting: String { + let uur = Calendar.current.component(.hour, from: Date()) + switch uur { + case 0...11: return "Goedemorgen," + case 12...17: return "Goedemiddag," + default: return "Goedenavond," + } + } + + private var dagrapport: some View { + HStack(alignment: .top, spacing: 0) { + dashCel(titel: "FAMILIE", waarde: liveTeller, sub: "van \(familie.count) live") + verticaleLijn + dashCel(titel: "SALDO", waarde: saldoTekst.isEmpty ? "—" : saldoTekst, + sub: saldoLaag ? "onder €10 — bijvullen" : "OpenRouter", rood: saldoLaag) + verticaleLijn + dashCel(titel: "WACHT OP JOU", waarde: wachtendeGoedkeuringen == 0 ? "—" : "\(wachtendeGoedkeuringen)", + sub: "goedkeuringen", rood: wachtendeGoedkeuringen > 0) + verticaleLijn + dashCel(titel: "GESCHIEDENIS", waarde: "append-only", sub: "niets wordt gewist") + Spacer() + } + } + + private var liveTeller: String { + let actief = leeft.values.filter { $0 == "active" }.count + return familie.isEmpty ? "—" : "\(actief)" + } + + private var verticaleLijn: some View { + Rectangle().fill(Thema.kleur(.lijn)).frame(width: 1, height: 54) + } + + private func dashCel(titel: String, waarde: String, sub: String, rood: Bool = false) -> some View { + VStack(alignment: .leading, spacing: 3) { + Text(titel).font(Thema.tekst(8, gewicht: .semibold)).tracking(1.5) + .foregroundStyle(Thema.kleur(.gedempt)) + Text(waarde).font(Thema.display(22)) + .foregroundStyle(rood ? Color.red : Thema.kleur(.inkt)) + Text(sub).font(Thema.tekst(9)).foregroundStyle(Thema.kleur(.gedempt)) + } + .padding(.horizontal, 18) + } + + private var graafBlok: some View { + VStack(alignment: .leading, spacing: 10) { + HStack(alignment: .firstTextBaseline) { + Text("Knowledge Graph").font(Thema.display(20)) + Text("· het hele brein in één kaart — scroll, zoom, klik en lees") + .font(Thema.tekst(10)).foregroundStyle(Thema.kleur(.gedempt)) + Spacer() + Button("Openen") { onNavigeer(.graaf) } + .buttonStyle(.plain) + .font(Thema.tekst(11, gewicht: .medium)) + .foregroundStyle(Thema.kleur(.zacht)) + } + GraafView(runner: runner, repoPad: $repoPad, interpreter: $interpreter, + compactVoorbeeld: true) + .frame(height: 420) + .overlay(RoundedRectangle(cornerRadius: 4).stroke(Thema.kleur(.lijn))) + } + } + + // MARK: - Voorbeeldopdrachten (drie lokale demo's, advies 5) + + /// Drie kant-en-klare opdrachten uit de repo. Ze komen uit de adapter, niet uit + /// een tweede lijst in Swift — anders kan de demo losraken van het echte plan. + private var voorbeeldLijst: some View { + VStack(alignment: .leading, spacing: 8) { + if !voorbeelden.isEmpty { + Text("VOORBEELDEN").font(Thema.tekst(10, gewicht: .semibold)).tracking(3) + .foregroundStyle(Thema.kleur(.zacht)).padding(.top, 10) + Text("Kies er één. Je ziet eerst het plan, daarna beslis jij of het mag draaien.") + .font(.caption).foregroundStyle(.secondary) + ForEach(voorbeelden.indices, id: \.self) { i in + let v = voorbeelden[i] + Button { + Task { await startVoorbeeld(v) } + } label: { + VStack(alignment: .leading, spacing: 2) { + Text(v["titel"] as? String ?? "Voorbeeld").fontWeight(.medium) + Text(v["uitleg"] as? String ?? "").font(.caption) + .foregroundStyle(.secondary).lineLimit(3) + Text("\(v["stappen"] as? Int ?? 0) stappen · \(v["mens_stappen"] as? Int ?? 0) keer jouw besluit") + .font(.caption2).foregroundStyle(Thema.kleur(.gedempt)) + }.frame(maxWidth: .infinity, alignment: .leading).padding(8) + }.buttonStyle(.plain) + .disabled(bezig) + .overlay(alignment: .bottom) { Rectangle().fill(Thema.kleur(.lijn)).frame(height: 1) } + } + } + } + } + + @MainActor private func startVoorbeeld(_ v: [String: Any]) async { + await actie("nieuw", extra: ["titel": v["titel"] ?? "", + "profiel": v["profiel"] ?? "", + "criteria": v["criteria"] ?? []]) + } + + private var formulier: some View { + VStack(alignment: .leading, spacing: 16) { + Text("Wat wil je bereiken?").font(Thema.display(26)) + TextField("Naam van je opdracht", text: $titel) + Picker("Stappenplan", selection: $profiel) { + Text("Kies een profiel").tag("") + ForEach(profielen.indices, id: \.self) { i in + let naam = profielen[i]["naam"] as? String ?? "" + Text(naam).tag(naam) + } + } + Text("Geslaagd wanneer…").fontWeight(.semibold) + TextEditor(text: $criterium).frame(minHeight: 90).border(Color.secondary.opacity(0.3)) + Text("Eén acceptatiecriterium per regel. Grow Kit toont straks welke controles dit technisch bewijzen en wat jij nog moet beoordelen.") + .font(.callout).foregroundStyle(.secondary) + Button("Maak plan — nog niets uitvoeren") { + Task { await actie("nieuw", extra: ["titel": titel, "profiel": profiel, + "criteria": criterium.split(separator: "\n").map(String.init)]) } + }.disabled(bezig || titel.isEmpty || profiel.isEmpty || criterium.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty) + }.textFieldStyle(.roundedBorder) + } + + @ViewBuilder private func detail(_ d: [String: Any]) -> some View { + let status = d["status"] as? String ?? "concept" + let plan = d["profiel"] as? [String: Any] ?? [:] + let rapport = d["rapport"] as? [String: Any] ?? [:] + let stappen = rapport["stappen"] as? [[String: Any]] ?? [] + let panic = (d["panic"] as? [String: Any])?["actief"] as? Bool ?? false + Text(d["titel"] as? String ?? "Opdracht").font(Thema.display(28)) + Text(label(status)).font(.headline) + Text("Opdracht → Plan → Goedkeuring → Uitvoering → Bewijs → Resultaat") + .font(.callout).foregroundStyle(.secondary) + GroupBox("Afgesproken resultaat") { + VStack(alignment: .leading, spacing: 6) { + ForEach(plan["acceptatiecriteria"] as? [String] ?? [], id: \.self) { Text("• " + $0) } + Text("Uitvoer: \(d["doel"] as? String ?? "")").textSelection(.enabled) + Text("Gegevensroute: \(routeLabel(d))").fontWeight(.medium) + if let r = d["gegevensroute"] as? [String: Any] { + if let uitleg = r["uitleg"] as? String { + Text(uitleg).font(.caption).foregroundStyle(.secondary) + } + if let waarschuwing = r["waarschuwing"] as? String { + Text(waarschuwing).font(.caption).foregroundStyle(.red) + } + let verzendt = r["verzendt"] as? [String] ?? [] + if !verzendt.isEmpty { + DisclosureGroup("Wat er deze opdracht verzonden kan worden (\(verzendt.count))") { + VStack(alignment: .leading, spacing: 4) { + ForEach(verzendt, id: \.self) { regel in + Text(regel).font(.system(.caption, design: .monospaced)) + .textSelection(.enabled) + } + } + } + } + } + Text("Kosten: \(kosten(d)) · Looptijd: \(Int(d["seconden"] as? Double ?? 0)) s · Beslissingen: \(d["ingrepen"] as? Int ?? 0)") + }.frame(maxWidth: .infinity, alignment: .leading).padding(6) + } + DisclosureGroup("Bekijk het volledige uitvoeringsplan") { + Text(json(plan)).font(.system(.caption, design: .monospaced)).textSelection(.enabled) + } + if cloudNodig(d) && !toestemmingGegeven(d) { + GroupBox("Deze opdracht gaat naar buiten (cloud)") { + VStack(alignment: .leading, spacing: 10) { + Text("Er gaat inhoud naar een clouddienst. Zonder jouw expliciete toestemming start er niets — de motor weigert het ook als je op uitvoeren drukt.") + .font(.callout).foregroundStyle(.secondary) + TextField("Waarom is dit hier goed?", text: $toelichting).textFieldStyle(.roundedBorder) + Button("Toestemming geven — gegevens mogen naar buiten") { + Task { await geefToestemming(true) } + }.disabled(bezig || toelichting.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty) + }.padding(6) + } + } + if cloudNodig(d) && toestemmingGegeven(d) { + HStack(spacing: 10) { + Text("Je gaf toestemming voor deze cloudroute.").font(.callout) + Button("Toestemming intrekken") { Task { await geefToestemming(false) } } + .disabled(bezig || toelichting.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty) + } + } + if panic { + Text("PANIC actief: er starten geen nieuwe commando’s. Een lopend commando wordt niet afgebroken.").foregroundStyle(.red) + Button("PANIC handmatig herstellen") { Task { await actie("herstel") } } + } else { + HStack { + if ["concept", "gepauzeerd", "bezig", "afgekeurd", "gefaald"].contains(status) { + Button(status == "concept" ? "Plan en grenzen goedkeuren · uitvoeren" : "Hervatten bevestigen") { + Task { await actie("uitvoeren", extra: ["bevestig": true, "plan_hash": d["plan_hash"] ?? ""]) } + }.disabled(bezig || (cloudNodig(d) && !toestemmingGegeven(d))) + if cloudNodig(d) && !toestemmingGegeven(d) { + Text("Uitvoeren wacht op je toestemming hierboven — deze route gaat naar buiten.") + .font(.caption).foregroundStyle(.secondary) + } + } + Button("Pauzeer nieuwe stappen", role: .destructive) { Task { await pauzeer() } } + } + } + if status == "bezig" && !bezig { + Text("Deze run is actief of onderbroken. Ververs eerst. Bij hervatten: controleer of een onvoltooide stap al effect had; geslaagde stappen worden overgeslagen.").font(.callout) + } + if status == "wacht_op_mens" || status == "resultaat" { + GroupBox(status == "wacht_op_mens" ? "Jouw besluit is nodig" : "Beoordeel het resultaat") { + VStack(alignment: .leading, spacing: 12) { + Button("Open resultaatmap") { + if let pad = d["doel"] as? String { NSWorkspace.shared.open(URL(fileURLWithPath: pad)) } + } + TextField("Wat heb je inhoudelijk gecontroleerd?", text: $toelichting).textFieldStyle(.roundedBorder) + HStack { + Button("Goedkeuren") { Task { await oordeel(true) } } + Button("Afkeuren") { Task { await oordeel(false) } } + }.disabled(bezig || toelichting.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty) + }.padding(6) + } + } + if status == "goedgekeurd" { Text("Door jou goedgekeurd: \(d["toelichting"] as? String ?? "")") } + ForEach(stappen.indices, id: \.self) { i in + let stap = stappen[i] + GroupBox(stap["id"] as? String ?? "Stap") { + VStack(alignment: .leading, spacing: 6) { + Text(stap["criterium"] as? String ?? "") + Text("Technisch: \(label(stap["technisch"] as? String ?? ""))") + Text("Inhoudelijk: \(label(stap["inhoudelijk"] as? String ?? ""))") + Text("Menselijke stapgoedkeuring: \(label(stap["mens"] as? String ?? ""))") + Text(stap["bewijs"] as? String ?? "").font(.caption).textSelection(.enabled) + }.frame(maxWidth: .infinity, alignment: .leading).padding(6) + } + } + Text(rapport["uitleg"] as? String ?? "").font(.caption).foregroundStyle(.secondary) + DisclosureGroup("Geschiedenis en bewijsdetails") { + Text(json(["opdracht": d["geschiedenis"] ?? [], "stappen": d["geschiedenis_stappen"] ?? []])) + .font(.system(.caption, design: .monospaced)).textSelection(.enabled) + } + } + + private func label(_ value: String) -> String { value.replacingOccurrences(of: "_", with: " ").capitalized } + // MARK: - Gegevensroute (advies 6) + + private func routeSoort(_ d: [String: Any]) -> String { + (d["gegevensroute"] as? [String: Any])?["soort"] as? String ?? "lokaal" + } + private func routeLabel(_ d: [String: Any]) -> String { + switch routeSoort(d) { + case "cloud": return "Cloud — er gaat inhoud naar buiten" + case "eigen_vps": return "Eigen VPS — jouw server, niets daarbuiten" + default: return "Lokaal — geen netwerkcommando's in het plan" + } + } + private func cloudNodig(_ d: [String: Any]) -> Bool { routeSoort(d) == "cloud" } + private func toestemmingGegeven(_ d: [String: Any]) -> Bool { d["cloud_toestemming"] as? Bool ?? false } + private func kosten(_ d: [String: Any]) -> String { + guard let bedrag = d["kosten_eur"] as? Double else { return "niet gemeten" } + return String(format: "€ %.2f", bedrag) + } + private func json(_ value: Any) -> String { + guard let data = try? JSONSerialization.data(withJSONObject: value, options: [.prettyPrinted, .sortedKeys]) else { return "" } + return String(data: data, encoding: .utf8) ?? "" + } + @MainActor private func laad() async { + do { + let lijst = try await runner.roep(repoPad: repoPad, interpreter: interpreter, commando: "opdrachten", invoer: [:]) + if !lijst.ok { throw AdapterFout.proces(lijst.fout ?? "Laden mislukt") } + opdrachten = lijst.data["opdrachten"] as? [[String: Any]] ?? [] + let fouten = lijst.data["fouten"] as? [String] ?? [] + if !fouten.isEmpty { fout = fouten.joined(separator: "\n") } + let p = try await runner.roep(repoPad: repoPad, interpreter: interpreter, commando: "profielen", invoer: [:]) + profielen = p.data["profielen"] as? [[String: Any]] ?? [] + if let v = try? await runner.roep(repoPad: repoPad, interpreter: interpreter, + commando: "opdrachten", invoer: ["actie": "voorbeelden"]) { + voorbeelden = v.data["voorbeelden"] as? [[String: Any]] ?? [] + } + } catch { fout = error.localizedDescription } + if vandaag { await laadVandaag() } + } + /// Het dagoverzicht: naam, familie, saldo, wachtende goedkeuringen en de + /// ZT-3-herovariant. Elke bron apart, zodat één onbereikbare bron het hele + /// overzicht niet leegmaakt. + @MainActor private func laadVandaag() async { + let profielR = try? await runner.roep(repoPad: repoPad, interpreter: interpreter, commando: "profiel", invoer: ["actie": "lees"]) + let familieR = try? await runner.roep(repoPad: repoPad, interpreter: interpreter, commando: "familie", invoer: ["actie": "status"]) + let agentR = try? await runner.roep(repoPad: repoPad, interpreter: interpreter, commando: "agentstatus", invoer: [:]) + let saldoR = try? await runner.roep(repoPad: repoPad, interpreter: interpreter, commando: "saldo", invoer: [:]) + let keurR = try? await runner.roep(repoPad: repoPad, interpreter: interpreter, commando: "goedkeuringen", invoer: ["actie": "lijst"]) + if let profielR, profielR.ok, let profiel = profielR.data["profiel"] as? [String: Any], + let naam = profiel["naam"] as? String, !naam.isEmpty { + gebruikersNaam = naam + } + if let familieR, familieR.ok, let fam = familieR.data["familie"] as? [[String: Any]] { + familie = fam + } + if let agentR, let agents = agentR.data["agents"] as? [[String: Any]] { + var kaart: [String: String] = [:] + for a in agents { + if let naam = a["agent"] as? String, let st = a["status"] as? String { kaart[naam] = st } + } + leeft = kaart + } + if let saldoR, saldoR.ok, let rest = saldoR.data["resterend"] as? Double { + saldoTekst = String(format: "€ %.2f", rest) + saldoLaag = rest < 10.0 + } + if let keurR, keurR.ok, let items = keurR.data["items"] as? [[String: Any]] { + wachtendeGoedkeuringen = items.count + } + let nachtrondeNieuws = false // nachtelijke bouwronde-koppeling volgt in een latere slice + let uur = Calendar.current.component(.hour, from: Date()) + if let v = ZTHero.variant(uur: uur, goedkeuringen: wachtendeGoedkeuringen, + saldo: saldoLaag ? 0 : 100, saldoDrempel: 10, + nachtronde: nachtrondeNieuws) { + heroTekst = ZTHero.tekstVoor(variant: v, goedkeuringen: wachtendeGoedkeuringen) + } else { + heroTekst = "" + } + } + @MainActor private func actie(_ actie: String, extra: [String: Any] = [:]) async { + bezig = true; fout = nil + defer { bezig = false } + var invoer: [String: Any] = ["actie": actie] + if let id = dossier?["id"] { invoer["id"] = id } + invoer.merge(extra) { _, new in new } + do { + let r = try await runner.roep(repoPad: repoPad, interpreter: interpreter, commando: "opdrachten", invoer: invoer, timeOut: 3600) + if !r.ok { throw AdapterFout.proces(r.fout ?? "Opdracht mislukt") } + dossier = r.data; nieuw = false; toelichting = "" + await laad() + } catch { fout = error.localizedDescription } + } + @MainActor private func pauzeer() async { + guard let id = dossier?["id"] else { return } + do { + let r = try await runner.roep(repoPad: repoPad, interpreter: interpreter, commando: "opdrachten", invoer: ["actie": "panic", "id": id]) + if r.ok { dossier = r.data } else { fout = r.fout } + } catch { fout = error.localizedDescription } + } + @MainActor private func oordeel(_ goed: Bool) async { + await actie("beoordeel", extra: ["goedgekeurd": goed, "toelichting": toelichting]) + } + @MainActor private func geefToestemming(_ akkoord: Bool) async { + await actie("toestemming", extra: ["akkoord": akkoord, "toelichting": toelichting]) + } +} diff --git a/kern/growkit_automatiek.py b/kern/growkit_automatiek.py index 54a4d8c..0372e19 100644 --- a/kern/growkit_automatiek.py +++ b/kern/growkit_automatiek.py @@ -16,6 +16,7 @@ """ from __future__ import annotations +from kern.growkit_opslag import transactie, schrijf_atomair, voeg_gebeurtenissen_toe import json import re import uuid @@ -173,32 +174,54 @@ def _log_pad() -> Path: def _log(actie: str, detail: dict) -> None: - pad = _log_pad() - pad.parent.mkdir(parents=True, exist_ok=True) - regels = [] - if pad.exists(): - try: - regels = json.loads(pad.read_text()) - except (json.JSONDecodeError, OSError): - regels = [] - regels.append({"actie": actie, "tijd": _nu(), **detail}) - pad.write_text(json.dumps(regels, ensure_ascii=False, indent=1)) + voeg_gebeurtenissen_toe(_log_pad(), [{"actie": actie, "tijd": _nu(), **detail}]) -def _lees_alle() -> list[dict]: - pad = _opslag_pad() +def _lees_json(pad: Path) -> list[dict]: if not pad.exists(): return [] - try: - return json.loads(pad.read_text()) - except (json.JSONDecodeError, OSError): - return [] + data = json.loads(pad.read_text()) + if not isinstance(data, list) or not all(isinstance(x, dict) for x in data): + raise ValueError(f"Ongeldig opslagbestand: {pad}") + return data + + +def _staat_pad() -> Path: + return _opslag_pad().with_suffix(".store.json") -def _schrijf_alle(plannen: list[dict]) -> None: - pad = _opslag_pad() - pad.parent.mkdir(parents=True, exist_ok=True) - pad.write_text(json.dumps(plannen, ensure_ascii=False, indent=1)) +def _lees_alle() -> list[dict]: + # Eén snapshot bevat plannen én gebeurtenissen. Oude bestanden blijven + # compatibele exports; de oorspronkelijke data wordt bij eerste mutatie geïmporteerd. + if _staat_pad().exists(): + return json.loads(_staat_pad().read_text())["plannen"] + return _lees_json(_opslag_pad()) + + +def _mutatie(plan: dict, actie: str) -> None: + with transactie(_staat_pad(), {}) as staat: + if not staat: + staat.update(plannen=_lees_json(_opslag_pad()), gebeurtenissen=_lees_json(_log_pad())) + plannen = staat["plannen"] + if actie == "toevoegen": + plannen.append(plan) + else: + for i, bestaand in enumerate(plannen): + if bestaand["id"] == plan["id"]: + if plan.get("revisie", 0) != bestaand.get("revisie", 0): + raise ValueError("Plan is ondertussen gewijzigd — laad het opnieuw") + plan["revisie"] = bestaand.get("revisie", 0) + 1 + plannen[i] = plan + break + else: + raise ValueError(f"Onbekend plan: {plan['id']}") + staat["gebeurtenissen"].append({"actie": actie, "tijd": _nu(), "id": plan["id"], + "status": plan["status"], "plan": plan.copy()}) + # Serialize exports under the same lock, reading the latest committed state. + # A crash here leaves the authoritative store intact; next mutation refreshes exports. + with transactie(_staat_pad(), {}) as staat: + schrijf_atomair(_opslag_pad(), staat["plannen"]) + schrijf_atomair(_log_pad(), staat["gebeurtenissen"]) def voeg_toe(titel: str, blokken: dict) -> dict: @@ -212,11 +235,7 @@ def voeg_toe(titel: str, blokken: dict) -> dict: plan["blokken"] = blokken if valideer_klaar(plan)["geldig"]: plan["status"] = "klaar" - plannen = _lees_alle() - plannen.append(plan) - _schrijf_alle(plannen) - _log("toevoegen", {"id": plan["id"], "titel": plan["titel"], - "status": plan["status"]}) + _mutatie(plan, "toevoegen") return plan @@ -236,15 +255,14 @@ def lees(plan_id: str) -> dict: def bewaar(plan: dict) -> dict: """Plan terugwegen (na bewerking of status-wissel).""" - plannen = _lees_alle() - for i, p in enumerate(plannen): - if p["id"] == plan["id"]: - plan["gewijzigd"] = _nu() - plannen[i] = plan - _schrijf_alle(plannen) - _log("bewaar", {"id": plan["id"], "status": plan["status"]}) - return plan - raise ValueError(f"Onbekend plan: {plan['id']}") + secret = _heeft_secret(plan.get("blokken", {})) + if secret: + raise ValueError(f"Secret geweigerd in plan: {secret}") + if plan.get("status") == "klaar" and not valideer_klaar(plan)["geldig"]: + raise ValueError("Een klaar plan moet volledig en geldig blijven") + plan["gewijzigd"] = _nu() + _mutatie(plan, "bewaar") + return plan # --------------------------------------------------------------------------- diff --git a/kern/growkit_bewijs.py b/kern/growkit_bewijs.py index f02be1a..ee1ec61 100644 --- a/kern/growkit_bewijs.py +++ b/kern/growkit_bewijs.py @@ -16,8 +16,8 @@ def _shell_check(bewijs: dict, doel: Path, **_) -> tuple[bool, str]: resultaat = subprocess.run(bewijs["commando"], shell=True, cwd=doel, capture_output=True, text=True, timeout=60) tekst = resultaat.stdout + resultaat.stderr - geslaagd = bewijs["verwacht_substr"] in tekst - return geslaagd, f"shell_check: zocht '{bewijs['verwacht_substr']}', kreeg: {tekst.strip()[:200]!r}" + geslaagd = resultaat.returncode == bewijs.get("verwacht_exitcode", 0) and bewijs["verwacht_substr"] in tekst + return geslaagd, f"shell_check: exitcode {resultaat.returncode}; zocht '{bewijs['verwacht_substr']}', kreeg: {tekst.strip()[:200]!r}" def _http_check(bewijs: dict, doel: Path, **_) -> tuple[bool, str]: @@ -52,8 +52,14 @@ def _json_valid(bewijs: dict, doel: Path, **_) -> tuple[bool, str]: return False, f"json_valid: lengte {len(data)} != {bewijs['exacte_lengte']}" if "verplicht_veld" in bewijs: items = data if isinstance(data, list) else [data] - if not all(bewijs["verplicht_veld"] in item for item in items): + if not all(isinstance(item, dict) and bewijs["verplicht_veld"] in item for item in items): return False, f"json_valid: veld {bewijs['verplicht_veld']!r} ontbreekt" + if "verwacht_waarden" in bewijs: + if not isinstance(data, dict) or not isinstance(bewijs["verwacht_waarden"], dict): + return False, "json_valid: verwacht_waarden vereist objecten" + for sleutel, waarde in bewijs["verwacht_waarden"].items(): + if sleutel not in data or type(data[sleutel]) is not type(waarde) or data[sleutel] != waarde: + return False, f"json_valid: waarde van {sleutel!r} wijkt af" return True, f"json_valid: {bewijs['pad']} OK" diff --git a/kern/growkit_motor.py b/kern/growkit_motor.py index 4cd7b64..9e806d5 100644 --- a/kern/growkit_motor.py +++ b/kern/growkit_motor.py @@ -9,12 +9,15 @@ bulk, later). 'gefaald'/'onduidelijk'/geen config → klassiek mens-moment. Machine-bewijs-stappen gaan nooit naar een reviewer. """ + +from kern.growkit_opslag import voeg_gebeurtenissen_toe import datetime import json import subprocess from pathlib import Path from kern.growkit_bewijs import controleer +from kern.growkit_panic import is_panic_actief def vervang_growkit_pad(profiel: dict, growkit_root: Path) -> dict: @@ -39,26 +42,36 @@ def _nu() -> str: def voer_stap_uit(stap: dict, doel: Path, sjablonen_map: Path | None) -> tuple[bool, str]: """Eén stap: commando → bewijs → (alternatief) → mens.""" - resultaat = subprocess.run(stap["commando"], shell=True, cwd=doel, - capture_output=True, text=True, timeout=300) - ok, bewijstekst = controleer(stap["bewijs"], doel, sjablonen_map=sjablonen_map) - if not ok and stap.get("bij_falen", {}).get("alternatief_commando"): - subprocess.run(stap["bij_falen"]["alternatief_commando"], shell=True, cwd=doel, - capture_output=True, text=True, timeout=300) - ok, bewijstekst = controleer(stap["bewijs"], doel, sjablonen_map=sjablonen_map) - if not ok: - bewijstekst += " — ook na alternatief_commando" - return ok, bewijstekst + commando = stap["commando"] + alternatief = stap.get("bij_falen", {}).get("alternatief_commando") + pogingen = [commando] + ([alternatief] if alternatief else []) + for poging in pogingen: + if is_panic_actief(doel): + return False, "PANIC: geen nieuwe commando's; herstel handmatig." + try: + resultaat = subprocess.run(poging, shell=True, cwd=doel, + capture_output=True, text=True, timeout=300) + if is_panic_actief(doel): + return False, "PANIC: tijdens dit commando geactiveerd; het commando liep af, bewijs en vervolg gepauzeerd." + if resultaat.returncode != 0: + ok, bewijstekst = False, f"commando faalde: exitcode {resultaat.returncode}" + else: + ok, bewijstekst = controleer(stap["bewijs"], doel, sjablonen_map=sjablonen_map) + except (subprocess.TimeoutExpired, OSError) as e: + ok, bewijstekst = False, f"uitvoering onderbroken: {type(e).__name__}" + if ok: + return True, bewijstekst + return False, bewijstekst def _log(logboek: Path, stap_id: str, status: str, bewijstekst: str, extra: dict | None = None) -> None: - entries = json.loads(logboek.read_text(encoding="utf-8")) if logboek.exists() else [] + entries = [] entry = {"stap": stap_id, "status": status, "bewijs": bewijstekst, "tijdstip": _nu()} if extra: entry.update(extra) entries.append(entry) - logboek.write_text(json.dumps(entries, indent=2, ensure_ascii=False) + "\n", encoding="utf-8") + voeg_gebeurtenissen_toe(logboek, entries) def vangnet_pad_voor(doel: Path) -> Path: @@ -66,7 +79,7 @@ def vangnet_pad_voor(doel: Path) -> Path: def _behandel_mensstap(stap: dict, logboek: Path, reviewconfig: dict | None, - vangnet: Path | None = None) -> None: + vangnet: Path | None = None) -> bool: """Mens-stap: reviewer eerst (indien geconfigureerd), anders klassiek mens-moment.""" instructie = stap["mens_nodig"].get("instructie", "") rol = stap.get("review") @@ -82,28 +95,38 @@ def _behandel_mensstap(stap: dict, logboek: Path, reviewconfig: dict | None, "noot": "latere stappen bouwen mogelijk op deze nog-te-ratificeren stap"} _log(logboek, stap["id"], "review_ok_wacht_ratificatie", instructie, extra) print(f" [review-ok] {stap['id']}: reviewer '{rol}' oordeelde geslaagd — wacht op ratificatie.") - return # motor gaat door + return True # expliciete review-ok mag door tot bulk-ratificatie if oordeel is not None: extra = {"review_rol": rol, "review_oordeel": oordeel} _log(logboek, stap["id"], "wacht_op_mens", instructie, extra) print(f" [mens-moment] {stap['id']}: reviewer '{rol}' oordeelde '{oordeel}' — de mens beslist. {instructie}") - return + return False _log(logboek, stap["id"], "wacht_op_mens", instructie) print(f" [mens-moment] {stap['id']}: {instructie}") + return False def voer_uit(profiel: dict, doel: Path, logboek: Path, sjablonen_map: Path | None, reviewconfig: dict | None = None, vangnet: Path | None = None) -> bool: """Volledige run. Mens-stappen pauzeren (wacht_op_mens), bewijs-stappen bewijzen. + True betekent: het hele plan is gelopen. False betekent: de run stopte — + vóór een mens-moment, op PANIC of na een mislukte stap. Wát de reden was, + staat in het logboek; gebruik `uitkomst()` om pauze van falen te scheiden. + Wie False als "mislukt" leest, noemt een pauze onterecht een motor-faal. + `vangnet` is optioneel (Vangnet-fase 1): gezet betekent het dat elke stap-uitkomst en review-aanroep wordt vastgelegd. Faalt het vangnet, dan merkt de loop er niets van (fail-open).""" alles_geslaagd = True for stap in profiel["stappen"]: + if is_panic_actief(doel): + _log(logboek, stap["id"], "gepauzeerd", "PANIC: herstel vereist vóór hervatten") + return False if stap.get("mens_nodig"): - _behandel_mensstap(stap, logboek, reviewconfig, vangnet) - continue # fase 1: mens-momenten tonen we, auto-hervatten komt later + if not _behandel_mensstap(stap, logboek, reviewconfig, vangnet): + return False + continue ok, bewijstekst = voer_stap_uit(stap, doel, sjablonen_map) _log(logboek, stap["id"], "geslaagd" if ok else "gefaald", bewijstekst) if vangnet is not None: @@ -115,3 +138,61 @@ def voer_uit(profiel: dict, doel: Path, logboek: Path, sjablonen_map: Path | Non print(f" Stap {stap['id']} faalde na alternatief. Roep de mens.") return False return alles_geslaagd + + +# --- uitkomst van een run: pauze is geen fout -------------------------------- + +_MENS_STATUSSEN = ("wacht_op_mens", "review_ok_wacht_ratificatie") + + +def _laatste_status_per_stap(logboek: Path) -> dict[str, str]: + """Laatst gelogde status per stap (append-only: het laatste wint).""" + if not logboek.exists(): + return {} + try: + entries = json.loads(logboek.read_text(encoding="utf-8")) + except (json.JSONDecodeError, OSError): + return {} + laatste: dict[str, str] = {} + for entry in entries: + if entry.get("stap"): + laatste[entry["stap"]] = entry.get("status") + return laatste + + +def uitkomst(logboek: Path) -> str: + """Wat was de uitkomst van de laatste run? + + 'geslaagd' | 'wacht_op_mens' | 'gepauzeerd' | 'gefaald'. + + Een mens-moment is geen fout: de motor stopte omdat jij moet beslissen. + 'gefaald' wint altijd van de mens-statussen en 'gepauzeerd' (PANIC) daarna — + anders zou een echt gefaalde stap als "wacht op de mens" verdergaan. + """ + statussen = set(_laatste_status_per_stap(logboek).values()) + if "gefaald" in statussen: + return "gefaald" + if "gepauzeerd" in statussen: + return "gepauzeerd" + if statussen & set(_MENS_STATUSSEN): + return "wacht_op_mens" + return "geslaagd" + + +def machine_deel_voltooid(profiel: dict, logboek: Path) -> bool: + """Zijn alle stappen zónder mens_nodig geslaagd? + + Zo ja, dan is pauzeren geen half werk: de machine-kant is af en alleen jouw + bevestiging wacht nog (een boom volmaken en registreren mag dan). Pauzeert de + run vóór een latere machine-stap, dan is dit False — er is niets af te maken. + """ + from kern.growkit_hervat import reconstructie + + resultaat = reconstructie(logboek, profiel) + if resultaat.get("fout"): + return False + machine_stappen = [s for s in profiel.get("stappen", []) if not s.get("mens_nodig")] + if not machine_stappen: + return False + return all(resultaat["stappen"][s["id"]]["beslissing"] == "overslaan" + for s in machine_stappen) diff --git a/kern/growkit_oerwoud.py b/kern/growkit_oerwoud.py index 5b43041..85ebd25 100644 --- a/kern/growkit_oerwoud.py +++ b/kern/growkit_oerwoud.py @@ -4,6 +4,8 @@ brein, stuurt VOORSTELLEN append-only door en leest het brein alleen-lezen. De drift-guard (§13) is hard: omgevings-specifieke staat reist nooit mee. """ + +from kern.growkit_opslag import voeg_gebeurtenissen_toe import datetime import json import os @@ -187,7 +189,7 @@ def controleer_geboortebewijs(bestand: Path) -> list[str]: def log_geboorte_entry(logboek: Path, bewijstekst: str) -> None: """Append-only systeem-entry over het geboortebewijs (patroon: mijlpaal).""" - entries = json.loads(logboek.read_text(encoding="utf-8")) if logboek.exists() else [] + entries = [] entries.append({ "type": "geboorte", "stap": "geboortebewijs", @@ -195,7 +197,7 @@ def log_geboorte_entry(logboek: Path, bewijstekst: str) -> None: "bewijs": bewijstekst, "tijdstip": _nu(), }) - logboek.write_text(json.dumps(entries, indent=2, ensure_ascii=False) + "\n", encoding="utf-8") + voeg_gebeurtenissen_toe(logboek, entries) def volmaak_na_plant(doel: Path, logboek: Path) -> bool: @@ -269,7 +271,7 @@ def stuur_voorstellen(boom_doel: Path, brein_pad: Path) -> tuple[int, list[str]] def log_gebeurtenis(logboek: Path, bewijstekst: str) -> None: """Append-only gebeurtenis in het boom-logboek (doorstroom e.d.).""" - entries = json.loads(logboek.read_text(encoding="utf-8")) if logboek.exists() else [] + entries = [] entries.append({ "type": "doorstroom", "stap": "oerwoud", @@ -277,7 +279,7 @@ def log_gebeurtenis(logboek: Path, bewijstekst: str) -> None: "bewijs": bewijstekst, "tijdstip": _nu(), }) - logboek.write_text(json.dumps(entries, indent=2, ensure_ascii=False) + "\n", encoding="utf-8") + voeg_gebeurtenissen_toe(logboek, entries) def status_data(doel: Path) -> dict: @@ -579,13 +581,13 @@ def log_run_latch(logboek: Path, status: str) -> None: Bij aanvang van een loop-run: {"type": "run", "status": "gestart", "pid": os.getpid()}; bij normaal einde: status "beeindigd". Lees via levensignaal() — 'gestart' zonder levend pid = gestopt (crash).""" - entries = json.loads(logboek.read_text(encoding="utf-8")) if logboek.exists() else [] + entries = [] entry = {"type": "run", "status": status, "tijdstip": _nu()} if status == "gestart": entry["pid"] = os.getpid() entries.append(entry) logboek.parent.mkdir(parents=True, exist_ok=True) - logboek.write_text(json.dumps(entries, indent=2, ensure_ascii=False) + "\n", encoding="utf-8") + voeg_gebeurtenissen_toe(logboek, entries) def acties_overzicht(doel: Path) -> dict: @@ -721,11 +723,10 @@ def curate_items(brein_pad: Path | None, items: list[dict]) -> list[dict]: f.write(f"- {naam}: {reden}\n") status = "afgewezen" detail = reden - entries = json.loads(logboek.read_text(encoding="utf-8")) if logboek.exists() else [] + entries = [] entries.append({"type": "curatie", "item": naam, "status": status, "bewijs": detail, "tijdstip": _nu()}) - logboek.write_text(json.dumps(entries, indent=2, ensure_ascii=False) + "\n", - encoding="utf-8") + voeg_gebeurtenissen_toe(logboek, entries) resultaten.append({"naam": naam, "status": status, "detail": detail}) return resultaten diff --git a/kern/growkit_opdrachten.py b/kern/growkit_opdrachten.py new file mode 100644 index 0000000..ec7dee5 --- /dev/null +++ b/kern/growkit_opdrachten.py @@ -0,0 +1,196 @@ +"""Eén blijvend dossier per opdracht, van bevestigd plan tot resultaat.""" +import contextlib +import fcntl +import hashlib +import json +import os +from pathlib import Path +import time +import uuid + +from kern import growkit_route +from kern.growkit_opslag import transactie, voeg_gebeurtenissen_toe +from kern.growkit_resultaat import bewijsrapport +from kern.growkit_motor import voer_uit, machine_deel_voltooid, uitkomst +from kern.growkit_hervat import reconstructie +from kern.growkit_ratificatie import ratificeer_bulk, wacht_ratificatie_stappen +from kern.growkit_panic import activeer_panic, herstel_na_panic, lees_status + + +def _root(): + return Path(os.environ.get('GROWKIT_OPDRACHTEN', str(Path.home() / '.growkit' / 'opdrachten'))) + + +def _pad(opdracht_id): + if not isinstance(opdracht_id, str) or str(uuid.UUID(opdracht_id)) != opdracht_id: + raise ValueError('Ongeldig opdracht-id') + return _root() / opdracht_id / 'opdracht.json' + + +def _hash(plan): + return hashlib.sha256(json.dumps(plan, sort_keys=True).encode()).hexdigest() + + +def nieuw(titel, criteria, profiel, sjablonen=None): + if not titel.strip() or not criteria or not all(isinstance(c, str) and c.strip() for c in criteria): + raise ValueError('Geef een titel en ten minste één acceptatiecriterium') + if not profiel.get('stappen'): + raise ValueError('Het plan bevat geen stappen') + opdracht_id = str(uuid.uuid4()) + pad = _pad(opdracht_id) + profiel = {**profiel, 'acceptatiecriteria': criteria} + with transactie(pad, {}) as data: + data.update(id=opdracht_id, titel=titel.strip(), profiel=profiel, + sjablonen=str(sjablonen) if sjablonen else None, + doel=str(pad.parent / 'resultaat'), status='concept', + aangemaakt=time.time(), seconden=0, ingrepen=0, + kosten_eur=0 if profiel.get('demo') else None, + gegevensroute=growkit_route.route(profiel)['soort'], + cloud_toestemming=False, + geschiedenis=[{'actie': 'concept', 'tijd': time.time()}]) + return lees(opdracht_id) + + +def lees(opdracht_id): + data = json.loads(_pad(opdracht_id).read_text()) + log = Path(data['doel']) / 'logboek.json' + entries = json.loads(log.read_text()) if log.exists() else [] + data['rapport'] = bewijsrapport(data['profiel'], entries) + data['geschiedenis_stappen'] = entries + data['plan_hash'] = _hash(data['profiel']) + data['panic'] = lees_status(Path(data['doel'])) + data['wachtende_stappen'] = wacht_ratificatie_stappen(log) + data['gegevensroute'] = growkit_route.route(data['profiel']) + return data + + +def lijst(): + items, fouten = [], [] + for pad in sorted(_root().glob('*/opdracht.json')): + try: + data = lees(pad.parent.name) + items.append({k: data[k] for k in ('id', 'titel', 'status', 'aangemaakt', 'seconden', 'ingrepen', 'kosten_eur')}) + except (ValueError, OSError, KeyError) as e: + fouten.append(f'{pad.parent.name}: {e}') + return {'opdrachten': sorted(items, key=lambda x: x['aangemaakt'], reverse=True), 'fouten': fouten} + + +def _wijzig(opdracht_id, actie, **velden): + with transactie(_pad(opdracht_id), {}) as data: + data.update(velden) + data['geschiedenis'].append({'actie': actie, 'tijd': time.time(), **velden}) + + +@contextlib.contextmanager +def _uitvoerslot(opdracht_id): + with open(_pad(opdracht_id).with_name('uitvoering.lock'), 'a') as f: + try: + fcntl.flock(f, fcntl.LOCK_EX | fcntl.LOCK_NB) + except BlockingIOError: + raise ValueError('Deze opdracht wordt al uitgevoerd') from None + try: + yield + finally: + fcntl.flock(f, fcntl.LOCK_UN) + + +def uitvoeren(opdracht_id, plan_hash, bevestig=False): + if bevestig is not True: + raise ValueError('Bevestig eerst het getoonde plan en de grenzen') + with _uitvoerslot(opdracht_id): + data = lees(opdracht_id) + if plan_hash != data['plan_hash']: + raise ValueError('Plan gewijzigd — bekijk en bevestig het actuele plan') + if data['status'] in ('resultaat', 'goedgekeurd'): + raise ValueError('Resultaat bestaat al; maak een nieuwe opdracht voor een nieuwe run') + doel = Path(data['doel']) + doel.mkdir(parents=True, exist_ok=True) + if data['panic']['actief']: + raise ValueError('PANIC actief — herstel handmatig vóór hervatten') + if (growkit_route.heeft_toestemming_nodig(data['profiel']) + and data.get('cloud_toestemming') is not True): + raise ValueError('Deze opdracht stuurt gegevens naar buiten (cloud) — ' + 'geef eerst je toestemming op de opdrachtpagina') + log = doel / 'logboek.json' + herstel = reconstructie(log, data['profiel']) + if herstel.get('fout'): + raise ValueError('Logboek corrupt; uitvoering geblokkeerd') + if data['wachtende_stappen']: + raise ValueError('Beoordeel eerst de wachtende mens-stappen') + rest = [s for s in data['profiel']['stappen'] if herstel['stappen'][s['id']]['beslissing'] != 'overslaan'] + start = time.monotonic() + _wijzig(opdracht_id, 'plan_bevestigd', status='bezig', ingrepen=data['ingrepen'] + 1) + try: + ok = voer_uit({**data['profiel'], 'stappen': rest}, doel, log, + Path(data['sjablonen']) if data['sjablonen'] else None) + if ok: + status = 'resultaat' + else: + stop = uitkomst(log) # al geïmporteerd + status = {'wacht_op_mens': 'wacht_op_mens', + 'gepauzeerd': 'gepauzeerd', + 'gefaald': 'gefaald'}.get(stop, 'gefaald') + except Exception as e: + _wijzig(opdracht_id, 'onderbroken', status='gepauzeerd', fout=str(e)) + raise + finally: + _wijzig(opdracht_id, 'looptijd', seconden=data['seconden'] + time.monotonic() - start) + _wijzig(opdracht_id, 'uitvoering', status=status) + return lees(opdracht_id) + + +def beoordeel(opdracht_id, goedgekeurd, toelichting): + if type(goedgekeurd) is not bool or not toelichting.strip(): + raise ValueError('Geef je oordeel en een inhoudelijke toelichting') + with _uitvoerslot(opdracht_id): + data = lees(opdracht_id) + if data['status'] not in ('resultaat', 'wacht_op_mens'): + raise ValueError('Er is geen resultaat of mens-stap om te beoordelen') + log = Path(data['doel']) / 'logboek.json' + wacht = data['wachtende_stappen'] + if wacht: + ratificeer_bulk(log, wacht if goedgekeurd else [], + [] if goedgekeurd else [{'stap_id': s, 'reden': toelichting} for s in wacht]) + # Keur je de laatste mens-stappen goed en is er daarna niets meer te + # draaien, dan ís dat het eindresultaat: één bevestiging, geen tweede + # herstart-ronde. Staat er nog machinewerk open, dan blijft het bij + # 'gepauzeerd' — eerst draaien, daarna het resultaat beoordelen. + if goedgekeurd and machine_deel_voltooid(data['profiel'], log): + status = 'goedgekeurd' + voeg_gebeurtenissen_toe(log, [{'type': 'acceptatie', 'status': status, + 'bewijs': toelichting, 'tijdstip': time.time()}]) + else: + status = 'gepauzeerd' + else: + status = 'goedgekeurd' if goedgekeurd else 'afgekeurd' + voeg_gebeurtenissen_toe(log, [{'type': 'acceptatie', 'status': status, + 'bewijs': toelichting, 'tijdstip': time.time()}]) + _wijzig(opdracht_id, 'menselijk_oordeel', status=status, toelichting=toelichting, + ingrepen=data['ingrepen'] + 1) + return lees(opdracht_id) + + +def toestemming(opdracht_id, akkoord, toelichting): + """Expliciete toestemming voor een cloudroute (advies 6) — mét reden. + + Zonder jouw akkoord start een cloud-opdracht niet. Het besluit landt in de + geschiedenis, dus intrekken (akkoord=False) is net zo zichtbaar als geven. + """ + if type(akkoord) is not bool or not str(toelichting).strip(): + raise ValueError('Geef je besluit en een korte reden') + with _uitvoerslot(opdracht_id): + data = lees(opdracht_id) + _wijzig(opdracht_id, 'cloudtoestemming', cloud_toestemming=akkoord, + toelichting=str(toelichting).strip(), ingrepen=data['ingrepen'] + 1) + return lees(opdracht_id) + + +def panic(opdracht_id, herstel=False): + data = lees(opdracht_id) + doel = Path(data['doel']) + doel.mkdir(parents=True, exist_ok=True) + if herstel: + herstel_na_panic(doel) + else: + activeer_panic(doel, 'Handmatig gepauzeerd vanuit opdrachtpagina') + return lees(opdracht_id) diff --git a/kern/growkit_opslag.py b/kern/growkit_opslag.py new file mode 100644 index 0000000..f31470e --- /dev/null +++ b/kern/growkit_opslag.py @@ -0,0 +1,59 @@ +"""Procesveilige JSON-transacties voor bestaande Grow Kit-bestanden. + +De lock staat naast het bestand (blijft stabiel bij os.replace). Een commit +schrijft en fsynct eerst een tijdelijk bestand, vervangt atomair de snapshot, +en fsynct de map. Een exception vóór replace bewaart de vorige snapshot. +Corruptie wordt nooit als een lege geschiedenis behandeld. +""" +from contextlib import contextmanager +from copy import deepcopy +import fcntl +import json +import os +from pathlib import Path +import tempfile + + +def schrijf_atomair(pad: Path, waarde) -> None: + pad = Path(pad) + pad.parent.mkdir(parents=True, exist_ok=True) + fd, naam = tempfile.mkstemp(prefix=f'.{pad.name}.', dir=pad.parent) + try: + with os.fdopen(fd, 'w', encoding='utf-8') as f: + json.dump(waarde, f, ensure_ascii=False, indent=2) + f.write('\n') + f.flush() + os.fsync(f.fileno()) + os.replace(naam, pad) + map_fd = os.open(pad.parent, os.O_RDONLY) + try: + os.fsync(map_fd) + finally: + os.close(map_fd) + finally: + if os.path.exists(naam): + os.unlink(naam) + + +@contextmanager +def transactie(pad: Path, standaard=None, *, append_only=False): + pad = Path(pad) + pad.parent.mkdir(parents=True, exist_ok=True) + with open(pad.with_name(pad.name + '.lock'), 'a') as lock: + fcntl.flock(lock, fcntl.LOCK_EX) + try: + waarde = json.loads(pad.read_text(encoding='utf-8')) if pad.exists() else deepcopy(standaard if standaard is not None else []) + if not isinstance(waarde, type(standaard if standaard is not None else [])): + raise ValueError(f'Ongeldig opslagformaat: {pad}') + origineel = deepcopy(waarde) + yield waarde + if append_only and waarde[:len(origineel)] != origineel: + raise ValueError('Bestaande gebeurtenissen mogen niet gewijzigd worden') + schrijf_atomair(pad, waarde) + finally: + fcntl.flock(lock, fcntl.LOCK_UN) + + +def voeg_gebeurtenissen_toe(pad: Path, gebeurtenissen: list[dict]) -> None: + with transactie(pad, append_only=True) as entries: + entries.extend(gebeurtenissen) diff --git a/kern/growkit_panic.py b/kern/growkit_panic.py index 4c8700d..8c987a2 100644 --- a/kern/growkit_panic.py +++ b/kern/growkit_panic.py @@ -3,6 +3,8 @@ # De Baas kan alleen via deze knop alles still zetten; herstart is handmatig. from __future__ import annotations +from kern.growkit_opslag import voeg_gebeurtenissen_toe, schrijf_atomair + import json from datetime import datetime, timezone from pathlib import Path @@ -21,18 +23,13 @@ def _status_pad(doel: Path) -> Path: def _log_panic(logboek: Path, status: str, reden: str) -> None: """Append-only: elke panic/herstel is een nieuwe entry, nooit een verwijderde.""" entries = [] - if logboek.exists(): - entries = json.loads(logboek.read_text(encoding="utf-8")) entries.append({ "stap": "PANIC", "status": status, "bewijs": reden, "tijdstip": _nu(), }) - logboek.write_text( - json.dumps(entries, indent=2, ensure_ascii=False) + "\n", - encoding="utf-8", - ) + voeg_gebeurtenissen_toe(logboek, entries) def activeer_panic(doel: Path, reden: str) -> dict: @@ -48,10 +45,7 @@ def activeer_panic(doel: Path, reden: str) -> dict: "reden": reden, "tijdstip": _nu(), } - _status_pad(doel).write_text( - json.dumps(payload, indent=2, ensure_ascii=False) + "\n", - encoding="utf-8", - ) + schrijf_atomair(_status_pad(doel), payload) logboek = doel / "logboek.json" _log_panic(logboek, "panic_actief", reden) return payload @@ -68,10 +62,7 @@ def herstel_na_panic(doel: Path) -> dict: "reden": "hersteld na panic", "tijdstip": _nu(), } - pad.write_text( - json.dumps(payload, indent=2, ensure_ascii=False) + "\n", - encoding="utf-8", - ) + schrijf_atomair(pad, payload) logboek = doel / "logboek.json" _log_panic(logboek, "panic_hersteld", "herstel na panic") return payload @@ -79,14 +70,7 @@ def herstel_na_panic(doel: Path) -> dict: def is_panic_actief(doel: Path) -> bool: """De motor roept dit vóór elke stap. Actieve panic = geen nieuwe stappen.""" - pad = _status_pad(Path(doel)) - if not pad.exists(): - return False - try: - data = json.loads(pad.read_text(encoding="utf-8")) - except (json.JSONDecodeError, OSError): - return False - return bool(data.get("actief", False)) + return lees_status(doel)["actief"] def lees_status(doel: Path) -> dict: @@ -95,6 +79,9 @@ def lees_status(doel: Path) -> dict: if not pad.exists(): return {"actief": False, "reden": "geen panic", "tijdstip": None} try: - return json.loads(pad.read_text(encoding="utf-8")) - except (json.JSONDecodeError, OSError): - return {"actief": False, "reden": "status-bestand onleesbaar", "tijdstip": None} + data = json.loads(pad.read_text(encoding="utf-8")) + if not isinstance(data, dict) or type(data.get("actief")) is not bool: + raise ValueError("ongeldige panic-status") + return data + except (ValueError, OSError): + return {"actief": True, "reden": "status-bestand onleesbaar — herstel handmatig", "tijdstip": None} diff --git a/kern/growkit_ratificatie.py b/kern/growkit_ratificatie.py index 4c63a84..ef4a76c 100644 --- a/kern/growkit_ratificatie.py +++ b/kern/growkit_ratificatie.py @@ -4,6 +4,7 @@ append-only verwerken van bulk-beslissingen (geratificeerd / herziening_nodig mét reden en doorloop-vermelding). Geen auto-rollback; de mens blijft curator. """ +from kern.growkit_opslag import voeg_gebeurtenissen_toe import datetime import json from pathlib import Path @@ -27,7 +28,7 @@ def wacht_ratificatie_stappen(logboek: Path) -> list[str]: if sid not in laatste: volgorde.append(sid) laatste[sid] = entry.get("status") - return [sid for sid in volgorde if laatste[sid] == "review_ok_wacht_ratificatie"] + return [sid for sid in volgorde if laatste[sid] in ("review_ok_wacht_ratificatie", "wacht_op_mens")] def ratificeer_bulk(logboek: Path, geratificeer: list[str], @@ -61,5 +62,5 @@ def ratificeer_bulk(logboek: Path, geratificeer: list[str], "bewijs": vermelding, "tijdstip": _nu()} entries.append(entry) geschreven.append(entry) - logboek.write_text(json.dumps(entries, indent=2, ensure_ascii=False) + "\n", encoding="utf-8") + voeg_gebeurtenissen_toe(logboek, geschreven) return geschreven diff --git a/kern/growkit_resultaat.py b/kern/growkit_resultaat.py new file mode 100644 index 0000000..7bc8ab1 --- /dev/null +++ b/kern/growkit_resultaat.py @@ -0,0 +1,28 @@ +"""Projecteer bewijs zonder technische checks als inhoudelijke waarheid te presenteren.""" + + +def bewijsrapport(profiel: dict, gebeurtenissen: list[dict]) -> dict: + stappen = [] + for stap in profiel.get('stappen', []): + regels = [e for e in gebeurtenissen if e.get('stap') == stap['id']] + laatste = regels[-1] if regels else {} + technisch = [e for e in regels if e.get('status') in ('geslaagd', 'gefaald')] + reviews = [e for e in regels if e.get('review_oordeel')] + mens = [e for e in regels if e.get('status') in ('geratificeerd', 'herziening_nodig')] + is_mens = bool(stap.get('mens_nodig')) + stappen.append({ + 'id': stap['id'], + 'criterium': stap.get('verwacht') or stap.get('mens_nodig', {}).get('instructie') or 'Geen inhoudelijk criterium opgegeven', + 'controle': stap.get('bewijs', {}).get('type', 'mens_verificatie'), + 'status': laatste.get('status', 'nog_niet_uitgevoerd'), + 'technisch': 'niet_van_toepassing' if is_mens else ('geslaagd' if technisch and technisch[-1]['status'] == 'geslaagd' else 'niet_bewezen'), + 'inhoudelijk': reviews[-1]['review_oordeel'] if reviews else 'niet_beoordeeld', + 'mens': mens[-1]['status'] if mens else 'niet_goedgekeurd', + 'bewijs': technisch[-1].get('bewijs', '') if technisch else '', + }) + technische_stappen = [s for s in stappen if s['technisch'] != 'niet_van_toepassing'] + return {'criteria': profiel.get('acceptatiecriteria', []), 'stappen': stappen, + 'technisch_gecontroleerd': bool(technische_stappen) and all(s['technisch'] == 'geslaagd' for s in technische_stappen), + 'inhoudelijk_beoordeeld': bool(stappen) and all(s['inhoudelijk'] == 'geslaagd' for s in stappen), + 'mens_goedgekeurd': bool(stappen) and all(s['mens'] == 'geratificeerd' for s in stappen), + 'uitleg': 'Technisch bewijs geldt uitsluitend voor de genoemde controle. Inhoudelijke kwaliteit en menselijke goedkeuring worden apart vastgelegd.'} diff --git a/kern/growkit_route.py b/kern/growkit_route.py new file mode 100644 index 0000000..5bf2aad --- /dev/null +++ b/kern/growkit_route.py @@ -0,0 +1,107 @@ +"""Wat verlaat je machine? (advies 6) + +Elke opdracht hoort vóór het draaien te laten zien waar gegevens heen gaan: +lokaal, via je eigen VPS, of naar een clouddienst. Een profiel mag dat zelf +verklaren (`gegevensroute`); deze module leidt de route ook af uit de commando's. +Wijken die twee van elkaar af, dan melden we dat — kiezen doen we niet stil. +""" +import re + +SOORTEN = ("lokaal", "eigen_vps", "cloud") + +# Commando's die de machine uitgaan. Eerst de zwaarste: cloud wint van eigen VPS. +# Losse woorden matchen op woordgrens (\bssh\b), vaste reeksen letterlijk. +_CLOUD = ("curl", "wget", "http://", "https://", "urllib", "requests", + "git push", "git clone", "git fetch", "pip install", "npm install", + "ftp", "sftp", "nc", "ncat") +_EIGEN_VPS = ("ssh", "scp", "rsync") + + +def _patroon(teken: str) -> re.Pattern: + """Los woord → woordgrens; vaste reeks (spatie, punt of ://) → letterlijk.""" + if " " in teken or teken.endswith(".") or "://" in teken: + return re.compile(re.escape(teken)) + return re.compile(rf"\b{re.escape(teken)}\b") + + +_CLOUD_PATRONEN = tuple(_patroon(teken) for teken in _CLOUD) +_VPS_PATRONEN = tuple(_patroon(teken) for teken in _EIGEN_VPS) + + +def _raakt(tekst: str, patronen: tuple[re.Pattern, ...]) -> bool: + """Case-insensitief: commando's zijn dat ook.""" + laag = tekst.lower() + return any(patroon.search(laag) for patroon in patronen) + +UITLEG = { + "lokaal": "Geen bekende netwerkcommando's gevonden in dit plan. Dit is een controle op het plan, geen garantie.", + "eigen_vps": "Er gaat iets naar je eigen server (GROWKIT_HOST); niets naar buiten.", + "cloud": "Er gaat inhoud naar een clouddienst buiten je eigen systemen.", +} + + +def _teksten(profiel: dict) -> list[tuple[str, str]]: + """Alle uitvoerbare commando's uit een profiel, met hun stap-id.""" + regels = [] + for stap in profiel.get("stappen", []): + if stap.get("commando"): + regels.append((str(stap.get("id", "?")), str(stap["commando"]))) + alternatief = (stap.get("bij_falen") or {}).get("alternatief_commando") + if alternatief: + regels.append((f"{stap.get('id', '?')} (alternatief)", str(alternatief))) + return regels + + +def afgeleid(profiel: dict) -> str: + """De route zoals de commando's die verraden (zonder verklaring).""" + teksten = [tekst for _, tekst in _teksten(profiel)] + if any(_raakt(tekst, _CLOUD_PATRONEN) for tekst in teksten): + return "cloud" + if any(_raakt(tekst, _VPS_PATRONEN) for tekst in teksten): + return "eigen_vps" + return "lokaal" + + +def verzendt(profiel: dict) -> list[str]: + """De regels die de machine zouden verlaten (leeg = niets).""" + return [f"{stap_id}: {tekst}" for stap_id, tekst in _teksten(profiel) + if _raakt(tekst, _CLOUD_PATRONEN) or _raakt(tekst, _VPS_PATRONEN)] + + +def verklaring(profiel: dict) -> dict | None: + """De route die het profiel zelf opgeeft (mag ontbreken).""" + blok = profiel.get("gegevensroute") + if isinstance(blok, dict) and blok.get("soort") in SOORTEN: + return blok + return None + + +def route(profiel: dict) -> dict: + """De route zoals de app hem toont. + + De verklaring van het profiel wint (een mens heeft die geschreven), maar de + afgeleide route staat er altijd naast. Is de verklaring lichter dan wat de + commando's doen, dan volgen we de zwaarste en zeggen we dat luid. + """ + afgeleide_soort = afgeleid(profiel) + blok = verklaring(profiel) + if blok is None: + return {"soort": afgeleide_soort, "bron": "afgeleid", + "verzendt": verzendt(profiel), "uitleg": UITLEG[afgeleide_soort], + "waarschuwing": None} + verklaarde_soort = blok["soort"] + zwaarste = verklaarde_soort + waarschuwing = None + if SOORTEN.index(afgeleide_soort) > SOORTEN.index(verklaarde_soort): + zwaarste = afgeleide_soort + waarschuwing = (f"Het profiel zegt '{verklaarde_soort}', maar een commando gaat " + f"verder dan dat ({afgeleide_soort}). Behandeld als '{zwaarste}'.") + return {"soort": zwaarste, "bron": "verklaard", + "verzendt": verzendt(profiel), + "uitleg": blok.get("uitleg") or UITLEG[zwaarste], + "waarschuwing": waarschuwing} + + +def heeft_toestemming_nodig(profiel: dict) -> bool: + """Alleen cloud vraagt om jouw expliciete toestemming.""" + return route(profiel)["soort"] == "cloud" diff --git a/kern/growkit_taken.py b/kern/growkit_taken.py index 5e869e4..b4cd338 100644 --- a/kern/growkit_taken.py +++ b/kern/growkit_taken.py @@ -3,6 +3,8 @@ Elke taak volgt het stappen-schema (§4): zonder `bewijs` met `type` bestaat de taak niet (poort-regel). Gebeurtenissen worden append-only gelogd. """ + +from kern.growkit_opslag import voeg_gebeurtenissen_toe import datetime import json from pathlib import Path @@ -108,7 +110,7 @@ def valideer_taak(taak: dict) -> list[str]: def log_taakgebeurtenis(pad: Path, taak_id: str, status: str, bewijs: str) -> None: """Append-only gebeurtenis per taak; bestaande entries blijven staan.""" pad.parent.mkdir(parents=True, exist_ok=True) - entries = json.loads(pad.read_text(encoding="utf-8")) if pad.exists() else [] + entries = [] entries.append({ "type": "taak", "taak": taak_id, @@ -116,7 +118,7 @@ def log_taakgebeurtenis(pad: Path, taak_id: str, status: str, bewijs: str) -> No "bewijs": bewijs, "tijdstip": datetime.datetime.now(datetime.timezone.utc).isoformat(timespec="seconds"), }) - pad.write_text(json.dumps(entries, indent=2, ensure_ascii=False) + "\n", encoding="utf-8") + voeg_gebeurtenissen_toe(pad, entries) def voer_taak_uit(doel: Path, taak: dict, reviewconfig=None, @@ -161,7 +163,7 @@ def voer_taak_uit(doel: Path, taak: dict, reviewconfig=None, log_taakgebeurtenis(taken_logboek, taak_id, "bezig", "motor-start") boom_logboek = doel / "logboek.json" if not boom_logboek.exists(): - boom_logboek.write_text("[]", encoding="utf-8") + voeg_gebeurtenissen_toe(boom_logboek, []) geslaagd = growkit_motor.voer_uit({"profiel": f"taak-{taak_id}", "stappen": [taak]}, doel, boom_logboek, None, reviewconfig=reviewconfig, vangnet=growkit_motor.vangnet_pad_voor(doel)) diff --git a/kern/growkit_voorbeelden.py b/kern/growkit_voorbeelden.py new file mode 100644 index 0000000..c9add62 --- /dev/null +++ b/kern/growkit_voorbeelden.py @@ -0,0 +1,61 @@ +"""Drie lokale voorbeeldopdrachten (advies 5). + +Eén bron: elk voorbeeldprofiel in profielen/ draagt zijn eigen `voorbeeld`-blok +(titel, criteria, uitleg). Zo kan de lijst in de app niet losraken van het plan +dat werkelijk draait. Een voorbeeld werkt zonder VPS, zonder netwerk en zonder +sleutels — dat is hieronder ook meteen een toetsbare regel. +""" +from seed import laad_profielen + +# Wat een voorbeeld nooit mag aanroepen: niets buiten deze machine. +_VERBODEN = ("ssh ", "scp ", "rsync ", "curl ", "wget ", "http://", "https://") + +VOORBEELD_STATUS = "voorbeeld" + + +def _is_voorbeeld(profiel: dict) -> bool: + return profiel.get("status") == VOORBEELD_STATUS and isinstance(profiel.get("voorbeeld"), dict) + + +def voorbeeld_profielen() -> list[dict]: + """Alle profielen die als voorbeeld gemarkeerd zijn (ook zonder voorbeeld-blok).""" + return [p for p in laad_profielen() if p.get("status") == VOORBEELD_STATUS] + + +def voorbeelden() -> list[dict]: + """De voorbeeldopdrachten zoals de app ze toont — een lijst zonder afwijkingen.""" + uit = [] + for profiel in sorted(laad_profielen(), key=lambda p: p.get("profiel", "")): + if not _is_voorbeeld(profiel): + continue + blok = profiel["voorbeeld"] + stappen = profiel.get("stappen", []) + uit.append({ + "id": profiel["profiel"], + "profiel": profiel["profiel"], + "titel": blok.get("titel", profiel["profiel"]), + "beschrijving": profiel.get("beschrijving", ""), + "uitleg": blok.get("uitleg", ""), + "criteria": list(blok.get("criteria", [])), + "stappen": len(stappen), + "mens_stappen": len([s for s in stappen if s.get("mens_nodig")]), + }) + return uit + + +def externe_aanroepen(profiel: dict) -> list[str]: + """Commando's die iets buiten deze machine zouden opvragen. + + Hoort leeg te zijn voor elk voorbeeld: een demo die een VPS of internet nodig + heeft, is geen demo. Retourneert de verdachte regels (leeg = in orde). + """ + verdacht = [] + for stap in profiel.get("stappen", []): + teksten = {"commando": str(stap.get("commando", ""))} + alternatief = (stap.get("bij_falen") or {}).get("alternatief_commando") + if alternatief: + teksten["alternatief"] = str(alternatief) + for soort, tekst in teksten.items(): + if any(verboden in tekst for verboden in _VERBODEN): + verdacht.append(f"{stap.get('id')} ({soort}): {tekst}") + return verdacht diff --git a/loop.py b/loop.py index ffb6060..009d7bf 100644 --- a/loop.py +++ b/loop.py @@ -6,6 +6,7 @@ uitvoeringspad. Kernregel in fase 4 (§11.1 hard): de loop voert niets uit dat niet de mensbevestiging heeft gehad. """ +from kern.growkit_opslag import voeg_gebeurtenissen_toe import json import sys from pathlib import Path @@ -77,7 +78,7 @@ def plant_profiel(invoer_fn=input) -> int: doel_pad.mkdir(parents=True, exist_ok=True) logboek = doel_pad / "logboek.json" if not logboek.exists(): - logboek.write_text("[]", encoding="utf-8") + voeg_gebeurtenissen_toe(logboek, []) with open(PROFILES_DIR / naam / "profiel.json", encoding="utf-8") as f: profiel = json.load(f) profiel = growkit_motor.vervang_growkit_pad(profiel, REPO.resolve()) @@ -86,11 +87,15 @@ def plant_profiel(invoer_fn=input) -> int: return 1 sjablonen = PROFILES_DIR / naam / "sjablonen" geslaagd = growkit_motor.voer_uit(profiel, doel_pad, logboek, sjablonen, reviewconfig=reviewconfig) - if geslaagd: + stop = None if geslaagd else growkit_motor.uitkomst(logboek) + # Pauze is geen fout: staat de mens-stap aan het eind van het plan, dan is de + # machine-kant af en mag de boom volmaakt en geregistreerd worden. + if geslaagd or (stop == "wacht_op_mens" + and growkit_motor.machine_deel_voltooid(profiel, logboek)): from kern import growkit_oerwoud growkit_oerwoud.volmaak_na_plant(doel_pad, logboek) growkit_oerwoud.registreer_nieuwe_boom(doel_pad, invoer_fn=invoer_fn) - return 0 if geslaagd else 2 + return 0 if geslaagd or stop == "wacht_op_mens" else 2 def hervat_boom(doel: Path | None = None, profiel: dict | None = None, invoer_fn=input) -> int: @@ -155,9 +160,12 @@ def hervat_boom(doel: Path | None = None, profiel: dict | None = None, invoer_fn PROFILES_DIR / profiel["profiel"] / "sjablonen", reviewconfig=reviewconfig) growkit_oerwoud.log_run_latch(logboek, "beeindigd") - if geslaagd: + stop = None if geslaagd else growkit_motor.uitkomst(logboek) + # Ook bij hervatten: pauze vóór de mens is geen faal (zie plant_profiel). + if geslaagd or (stop == "wacht_op_mens" + and growkit_motor.machine_deel_voltooid(profiel, logboek)): growkit_oerwoud.volmaak_na_plant(doel, logboek) - return 0 if geslaagd else 2 + return 0 if geslaagd or stop == "wacht_op_mens" else 2 def ratificeer(doel: Path, invoer_fn=input) -> int: diff --git a/profielen/documentenoverzicht/profiel.json b/profielen/documentenoverzicht/profiel.json new file mode 100644 index 0000000..17c14b4 --- /dev/null +++ b/profielen/documentenoverzicht/profiel.json @@ -0,0 +1,88 @@ +{ + "profiel": "documentenoverzicht", + "status": "voorbeeld", + "demo": true, + "gegevensroute": { + "soort": "lokaal", + "uitleg": "Leest de documentatiemap op deze machine en telt bestanden. Er wordt niets verzonden en er is geen sleutel nodig." + }, + "beschrijving": "Maakt een overzicht van de documenten in een map: hoeveel markdown-bestanden, waar ze staan en wat er opvalt. Draait volledig lokaal.", + "voorbeeld": { + "titel": "Documentenoverzicht", + "uitleg": "Grow Kit telt de markdown-bestanden in de documentatiemap en zet de lijst in een overzicht. Jij leest het na en beslist.", + "criteria": [ + "Het overzicht overzicht/overzicht.md bestaat en is gelijk aan het sjabloon", + "Het aantal markdown-bestanden staat in overzicht/markdown-aantal.txt", + "De bestandslijst staat in overzicht/markdown-lijst.txt" + ] + }, + "mappen": ["overzicht"], + "stappen": [ + { + "id": "stap-001", + "commando": "mkdir -p overzicht", + "verwacht": "de map overzicht bestaat in de opdrachtmap", + "bewijs": { + "type": "shell_check", + "commando": "test -d overzicht && echo OVERZICHT-OK", + "verwacht_substr": "OVERZICHT-OK" + }, + "bij_falen": { + "alternatief_commando": "mkdir -p ./overzicht", + "anders": "roep_mens" + }, + "idempotent": true + }, + { + "id": "stap-002", + "commando": "find \"{GROWKIT}/docs\" -name '*.md' | wc -l | tr -d ' ' > overzicht/markdown-aantal.txt", + "verwacht": "overzicht/markdown-aantal.txt bevat het aantal markdown-bestanden", + "bewijs": { + "type": "shell_check", + "commando": "test -s overzicht/markdown-aantal.txt && echo AANTAL-OK", + "verwacht_substr": "AANTAL-OK" + }, + "bij_falen": { + "alternatief_commando": null, + "anders": "roep_mens" + }, + "idempotent": true + }, + { + "id": "stap-003", + "commando": "find \"{GROWKIT}/docs\" -name '*.md' > overzicht/markdown-lijst.txt", + "verwacht": "overzicht/markdown-lijst.txt bestaat", + "bewijs": { + "type": "file_exists", + "pad": "overzicht/markdown-lijst.txt" + }, + "bij_falen": { + "alternatief_commando": null, + "anders": "roep_mens" + }, + "idempotent": true + }, + { + "id": "stap-004", + "commando": "cp \"{GROWKIT}/profielen/documentenoverzicht/sjablonen/overzicht.md\" ./overzicht/overzicht.md", + "verwacht": "overzicht/overzicht.md staat er en is identiek aan het sjabloon", + "bewijs": { + "type": "file_equals", + "sjabloon": "overzicht.md", + "pad": "overzicht/overzicht.md" + }, + "bij_falen": { + "alternatief_commando": null, + "anders": "roep_mens" + }, + "idempotent": true + }, + { + "id": "stap-005", + "mens_nodig": { + "instructie": "Lees overzicht/overzicht.md, overzicht/markdown-aantal.txt en overzicht/markdown-lijst.txt. Is dit overzicht compleet genoeg? Bevestig of wijs af." + }, + "verwacht": "jouw oordeel over het overzicht" + } + ] +} diff --git a/profielen/documentenoverzicht/sjablonen/overzicht.md b/profielen/documentenoverzicht/sjablonen/overzicht.md new file mode 100644 index 0000000..ce38151 --- /dev/null +++ b/profielen/documentenoverzicht/sjablonen/overzicht.md @@ -0,0 +1,16 @@ +# Documentenoverzicht + +Dit overzicht hoort bij één ronde. Grow Kit heeft de documenten geteld en de lijst +gemaakt; jij beoordeelt of het overzicht klopt. + +## Wat technisch is gecontroleerd + +- de map `overzicht/` bestaat +- het aantal markdown-bestanden staat in `overzicht/markdown-aantal.txt` +- de volledige bestandslijst staat in `overzicht/markdown-lijst.txt` +- dit overzicht is geplaatst vanuit het sjabloon (bestand gelijk aan sjabloon) + +## Wat jij nog beslist + +Tel je mee? Een aantal is pas bruikbaar als jij hebt gezien wát er geteld is — +bijvoorbeeld of losse notities meetellen of dat je alleen de echte documenten wilt. diff --git a/profielen/projectcontrole/profiel.json b/profielen/projectcontrole/profiel.json new file mode 100644 index 0000000..2a49e1a --- /dev/null +++ b/profielen/projectcontrole/profiel.json @@ -0,0 +1,89 @@ +{ + "profiel": "projectcontrole", + "status": "voorbeeld", + "demo": true, + "gegevensroute": { + "soort": "lokaal", + "uitleg": "Telt bestanden en controleert paden op deze machine. Er wordt niets verzonden en er is geen sleutel nodig." + }, + "beschrijving": "Controleert of een projectmap de basis op orde heeft en levert een kort rapport met tellingen. Draait volledig lokaal.", + "voorbeeld": { + "titel": "Projectcontrole", + "uitleg": "Grow Kit telt de kernbestanden, controleert of README, LICENSE en tests aanwezig zijn en legt het resultaat in een rapport. Jij leest het rapport en beslist.", + "criteria": [ + "Het rapport controle/controle.md bestaat en is gelijk aan het sjabloon", + "Het aantal kernbestanden staat in controle/kernbestanden.txt", + "De basiscontrole (README, LICENSE, tests) staat in controle/basis.txt" + ] + }, + "mappen": ["controle"], + "stappen": [ + { + "id": "stap-001", + "commando": "mkdir -p controle", + "verwacht": "de map controle bestaat in de opdrachtmap", + "bewijs": { + "type": "shell_check", + "commando": "test -d controle && echo CONTROLE-OK", + "verwacht_substr": "CONTROLE-OK" + }, + "bij_falen": { + "alternatief_commando": "mkdir -p ./controle", + "anders": "roep_mens" + }, + "idempotent": true + }, + { + "id": "stap-002", + "commando": "cp \"{GROWKIT}/profielen/projectcontrole/sjablonen/controle.md\" ./controle/controle.md", + "verwacht": "controle/controle.md staat er en is identiek aan het sjabloon", + "bewijs": { + "type": "file_equals", + "sjabloon": "controle.md", + "pad": "controle/controle.md" + }, + "bij_falen": { + "alternatief_commando": null, + "anders": "roep_mens" + }, + "idempotent": true + }, + { + "id": "stap-003", + "commando": "find \"{GROWKIT}/kern\" -name '*.py' | wc -l | tr -d ' ' > controle/kernbestanden.txt", + "verwacht": "controle/kernbestanden.txt bevat het aantal kernbestanden", + "bewijs": { + "type": "shell_check", + "commando": "test -s controle/kernbestanden.txt && echo TELLING-OK", + "verwacht_substr": "TELLING-OK" + }, + "bij_falen": { + "alternatief_commando": null, + "anders": "roep_mens" + }, + "idempotent": true + }, + { + "id": "stap-004", + "commando": "{ test -f \"{GROWKIT}/README.md\" && test -f \"{GROWKIT}/LICENSE\" && test -d \"{GROWKIT}/tests\"; } && printf 'basis in orde\\n' > controle/basis.txt", + "verwacht": "README, LICENSE en tests bestaan; controle/basis.txt legt dat vast", + "bewijs": { + "type": "file_exists", + "pad": "controle/basis.txt", + "bevat": "basis" + }, + "bij_falen": { + "alternatief_commando": "printf 'basis onvolledig\\n' > controle/basis.txt", + "anders": "roep_mens" + }, + "idempotent": true + }, + { + "id": "stap-005", + "mens_nodig": { + "instructie": "Lees controle/controle.md, controle/basis.txt en controle/kernbestanden.txt. Klopt deze controle? Bevestig of wijs af." + }, + "verwacht": "jouw oordeel over de controle" + } + ] +} diff --git a/profielen/projectcontrole/sjablonen/controle.md b/profielen/projectcontrole/sjablonen/controle.md new file mode 100644 index 0000000..5f75d21 --- /dev/null +++ b/profielen/projectcontrole/sjablonen/controle.md @@ -0,0 +1,17 @@ +# Projectcontrole + +Dit rapport hoort bij één controle-ronde. Grow Kit heeft de machine-kant gedaan; +jij geeft het inhoudelijke oordeel. + +## Wat technisch is gecontroleerd + +- de map `controle/` bestaat +- dit rapport is geplaatst vanuit het sjabloon (bestand gelijk aan sjabloon) +- het aantal kernbestanden is geteld in `controle/kernbestanden.txt` +- de basis (README, LICENSE, tests) is gecontroleerd in `controle/basis.txt` + +## Wat jij nog beslist + +Of deze uitkomst goed genoeg is om door te gaan. Een bestaand bestand bewijst nog +niet dat de inhoud klopt: lees het rapport, open de tellers en bevestig of wijs af +met een reden. diff --git a/profielen/terugkerend-rapport/profiel.json b/profielen/terugkerend-rapport/profiel.json new file mode 100644 index 0000000..d6344c8 --- /dev/null +++ b/profielen/terugkerend-rapport/profiel.json @@ -0,0 +1,89 @@ +{ + "profiel": "terugkerend-rapport", + "status": "voorbeeld", + "demo": true, + "gegevensroute": { + "soort": "lokaal", + "uitleg": "Leest de datum en telt scriptbestanden op deze machine. Er wordt niets verzonden en er is geen sleutel nodig." + }, + "beschrijving": "Maakt een vast rapport van één pagina met de datum en de stand van zaken, zodat je het elke keer opnieuw kunt draaien. Draait volledig lokaal.", + "voorbeeld": { + "titel": "Terugkerend rapport", + "uitleg": "Grow Kit zet de datum van vandaag in het rapport en telt de kernbestanden. Elk rondje levert hetzelfde soort rapport op, dus je kunt het blijven herhalen.", + "criteria": [ + "Het rapport rapport/rapport.md bestaat en is gelijk aan het sjabloon", + "De datum van vandaag staat in rapport/datum.txt", + "Het aantal scriptbestanden staat in rapport/scriptbestanden.txt" + ] + }, + "mappen": ["rapport"], + "stappen": [ + { + "id": "stap-001", + "commando": "mkdir -p rapport", + "verwacht": "de map rapport bestaat in de opdrachtmap", + "bewijs": { + "type": "shell_check", + "commando": "test -d rapport && echo RAPPORT-OK", + "verwacht_substr": "RAPPORT-OK" + }, + "bij_falen": { + "alternatief_commando": "mkdir -p ./rapport", + "anders": "roep_mens" + }, + "idempotent": true + }, + { + "id": "stap-002", + "commando": "date +%Y-%m-%d > rapport/datum.txt", + "verwacht": "rapport/datum.txt bestaat en legt de datum van vandaag vast", + "bewijs": { + "type": "shell_check", + "commando": "test -s rapport/datum.txt && echo DATUM-OK", + "verwacht_substr": "DATUM-OK" + }, + "bij_falen": { + "alternatief_commando": null, + "anders": "roep_mens" + }, + "idempotent": false + }, + { + "id": "stap-003", + "commando": "find \"{GROWKIT}/scripts\" -name '*.py' | wc -l | tr -d ' ' > rapport/scriptbestanden.txt", + "verwacht": "rapport/scriptbestanden.txt bevat het aantal scriptbestanden", + "bewijs": { + "type": "shell_check", + "commando": "test -s rapport/scriptbestanden.txt && echo SCRIPTS-OK", + "verwacht_substr": "SCRIPTS-OK" + }, + "bij_falen": { + "alternatief_commando": null, + "anders": "roep_mens" + }, + "idempotent": true + }, + { + "id": "stap-004", + "commando": "cp \"{GROWKIT}/profielen/terugkerend-rapport/sjablonen/rapport.md\" ./rapport/rapport.md", + "verwacht": "rapport/rapport.md staat er en is identiek aan het sjabloon", + "bewijs": { + "type": "file_equals", + "sjabloon": "rapport.md", + "pad": "rapport/rapport.md" + }, + "bij_falen": { + "alternatief_commando": null, + "anders": "roep_mens" + }, + "idempotent": true + }, + { + "id": "stap-005", + "mens_nodig": { + "instructie": "Lees rapport/rapport.md, rapport/datum.txt en rapport/scriptbestanden.txt. Klopt dit rondje? Bevestig of wijs af." + }, + "verwacht": "jouw oordeel over het rapport" + } + ] +} diff --git a/profielen/terugkerend-rapport/sjablonen/rapport.md b/profielen/terugkerend-rapport/sjablonen/rapport.md new file mode 100644 index 0000000..50e4e38 --- /dev/null +++ b/profielen/terugkerend-rapport/sjablonen/rapport.md @@ -0,0 +1,17 @@ +# Terugkerend rapport + +Dit is het vaste rapport van deze ronde. Dezelfde stappen leveren elke keer +hetzelfde soort rapport op, met de datum van die dag erbij. + +## Wat technisch is gecontroleerd + +- de map `rapport/` bestaat +- de datum van vandaag staat in `rapport/datum.txt` +- het aantal scriptbestanden staat in `rapport/scriptbestanden.txt` +- dit rapport is geplaatst vanuit het sjabloon (bestand gelijk aan sjabloon) + +## Wat jij nog beslist + +Is dit het rondje dat je wilde? Een terugkerend rapport is pas nuttig als je de +vorige versie ernaast kunt leggen — bevestig of wijs af met een reden, dan blijft +de geschiedenis eerlijk. diff --git a/profielen/tweede-brein/profiel.json b/profielen/tweede-brein/profiel.json index ee1f783..9915572 100644 --- a/profielen/tweede-brein/profiel.json +++ b/profielen/tweede-brein/profiel.json @@ -1,6 +1,10 @@ { "profiel": "tweede-brein", "status": "bewezen-vorm", + "gegevensroute": { + "soort": "lokaal", + "uitleg": "Maakt mappen en bestanden op deze machine (of op de map die jij aanwijst). Geen netwerk, geen sleutel." + }, "beschrijving": "Generiek tweede brein: een gecontroleerd geheugen naast een AI-agent. De agent leest en stelt voor, de mens keurt goed. Nooit overschrijven, alleen toevoegen.", "mappen": ["identiteit", "kennis", "projecten", "inbox", "logboek"], "stappen": [ diff --git a/seed.py b/seed.py index e1c969d..e587fc3 100644 --- a/seed.py +++ b/seed.py @@ -6,6 +6,8 @@ python3 seed.py --profiel tweede-brein --doel ~/mijn-brein python3 seed.py --slijp # Prompt-slijper (fase 3) """ + +from kern.growkit_opslag import voeg_gebeurtenissen_toe import argparse import datetime import json @@ -60,7 +62,7 @@ def vraag_mijlpaal_bevestiging(profiel: dict, doel: Path, logboek: Path, if antwoord != "ja": print(" Geen bevestiging — geen actie.") return False - entries = json.loads(logboek.read_text(encoding="utf-8")) if logboek.exists() else [] + entries = [] entries.append({ "type": "mijlpaal", "stap": "mijlpaal-start", @@ -68,7 +70,7 @@ def vraag_mijlpaal_bevestiging(profiel: dict, doel: Path, logboek: Path, "bewijs": "mijlpaal-controle bevestigd door de mens (§11.4)", "tijdstip": datetime.datetime.now(datetime.timezone.utc).isoformat(timespec="seconds"), }) - logboek.write_text(json.dumps(entries, indent=2, ensure_ascii=False) + "\n", encoding="utf-8") + voeg_gebeurtenissen_toe(logboek, entries) return True @@ -190,7 +192,7 @@ def main(argv: list[str] | None = None) -> int: doel.mkdir(parents=True, exist_ok=True) logboek = doel / "logboek.json" if not logboek.exists(): - logboek.write_text("[]", encoding="utf-8") + voeg_gebeurtenissen_toe(logboek, []) profiel_pad = PROFILES_DIR / keuze["profiel"] / "profiel.json" with open(profiel_pad, encoding="utf-8") as f: profiel = json.load(f) @@ -201,10 +203,13 @@ def main(argv: list[str] | None = None) -> int: return 1 sjablonen = PROFILES_DIR / keuze["profiel"] / "sjablonen" geslaagd = growkit_motor.voer_uit(profiel, doel, logboek, sjablonen, reviewconfig=reviewconfig) - if geslaagd: + stop = None if geslaagd else growkit_motor.uitkomst(logboek) + # Pauze is geen fout (zie loop.py): machine-kant af → boom volmaken. + if geslaagd or (stop == "wacht_op_mens" + and growkit_motor.machine_deel_voltooid(profiel, logboek)): from kern import growkit_oerwoud growkit_oerwoud.volmaak_na_plant(doel, logboek) - return 0 if geslaagd else 2 + return 0 if geslaagd or stop == "wacht_op_mens" else 2 if __name__ == "__main__": diff --git a/tests/test_automatiek.py b/tests/test_automatiek.py index 06ffaed..4a5f614 100644 --- a/tests/test_automatiek.py +++ b/tests/test_automatiek.py @@ -121,7 +121,8 @@ def test_plan_met_api_key_geweigerd(self): def test_toevoegen_met_secret_geweigerd(self): with tempfile.TemporaryDirectory() as tmp: with mock.patch.object(am, "_opslag_pad", - return_value=Path(tmp) / "plannen.json"): + return_value=Path(tmp) / "plannen.json"), \ + mock.patch.object(am, "_log_pad", return_value=Path(tmp) / "log.json"): with self.assertRaises(ValueError): # CI-vrijstellings-marker in dezelfde regel: dit is een # testfixture, geen echte key. Het patroon (ghp_+30) is @@ -139,7 +140,8 @@ class TestOpslagEnExport(unittest.TestCase): def test_toevoegen_en_lijst_en_lezen(self): with tempfile.TemporaryDirectory() as tmp: with mock.patch.object(am, "_opslag_pad", - return_value=Path(tmp) / "plannen.json"): + return_value=Path(tmp) / "plannen.json"), \ + mock.patch.object(am, "_log_pad", return_value=Path(tmp) / "log.json"): plan = am.voeg_toe(titel="Ochtendsamenvatting", blokken=_vol_blokken()) lijst = am.lijst() diff --git a/tests/test_execution_guards.py b/tests/test_execution_guards.py new file mode 100644 index 0000000..31c1d8d --- /dev/null +++ b/tests/test_execution_guards.py @@ -0,0 +1,93 @@ +import json +import tempfile +import unittest +from pathlib import Path +from unittest.mock import patch +from kern.growkit_motor import (voer_uit, voer_stap_uit, uitkomst, + machine_deel_voltooid) +from kern.growkit_bewijs import controleer +from kern.growkit_opslag import voeg_gebeurtenissen_toe +from kern.growkit_panic import activeer_panic, is_panic_actief, lees_status +from kern.growkit_ratificatie import wacht_ratificatie_stappen + +class ExecutionGuards(unittest.TestCase): + def setUp(self): + self.tmp = tempfile.TemporaryDirectory() + self.addCleanup(self.tmp.cleanup) + self.doel = Path(self.tmp.name) + self.log = self.doel / 'logboek.json' + self.stap = {'id': 'stap-2', 'commando': 'touch executed', + 'bewijs': {'type': 'file_exists', 'pad': 'executed'}} + + def test_wait_blocks_next_step_and_can_be_approved(self): + mens = {'id': 'stap-1', 'mens_nodig': {'instructie': 'Controleer'}} + self.assertFalse(voer_uit({'stappen': [mens, self.stap]}, self.doel, self.log, None)) + self.assertFalse((self.doel / 'executed').exists()) + self.assertEqual(wacht_ratificatie_stappen(self.log), ['stap-1']) + + def test_panic_blocks_direct_and_full_execution(self): + activeer_panic(self.doel, 'test') + self.assertFalse(voer_stap_uit(self.stap, self.doel, None)[0]) + self.assertFalse(voer_uit({'stappen': [self.stap]}, self.doel, self.log, None)) + self.assertFalse((self.doel / 'executed').exists()) + + def test_corrupt_or_invalid_panic_is_blocking(self): + for value in ('{', '[]', '{}', '{"actief": "false"}'): + (self.doel / 'panic_status.json').write_text(value) + self.assertTrue(is_panic_actief(self.doel)) + self.assertTrue(lees_status(self.doel)['actief']) + + def test_nonzero_check_cannot_succeed_from_output(self): + self.assertFalse(controleer({'type': 'shell_check', 'commando': 'echo OK; exit 1', + 'verwacht_substr': 'OK'}, self.doel)[0]) + + def test_panic_blocks_alternative_and_proof_command(self): + self.stap['bij_falen'] = {'alternatief_commando': 'touch alternative'} + def execute(*args, **kwargs): + activeer_panic(self.doel, 'during command') + return type('Result', (), {'returncode': 1})() + with patch('kern.growkit_motor.subprocess.run', side_effect=execute) as run: + self.assertFalse(voer_stap_uit(self.stap, self.doel, None)[0]) + self.assertEqual(run.call_count, 1) + + def test_timeout_becomes_logged_failure(self): + import subprocess + with patch('kern.growkit_motor.subprocess.run', side_effect=subprocess.TimeoutExpired('test', 300)): + self.assertFalse(voer_uit({'stappen': [self.stap]}, self.doel, self.log, None)) + self.assertEqual(json.loads(self.log.read_text())[-1]['status'], 'gefaald') + + # --- pauze is geen fout (advies 2, tweede ronde) ----------------------- + + def test_mens_pauze_heet_wacht_op_mens_en_niet_gefaald(self): + """Een mens-stap stopt de motor (pauze), maar is géén motor-faal.""" + mens = {'id': 'stap-1', 'mens_nodig': {'instructie': 'Controleer'}} + self.assertFalse(voer_uit({'stappen': [self.stap, mens]}, self.doel, self.log, None)) + self.assertEqual(uitkomst(self.log), 'wacht_op_mens') + # alle machine-stappen zijn klaar — alleen de mens wacht nog + self.assertTrue(machine_deel_voltooid({'stappen': [self.stap, mens]}, self.log)) + + def test_pauze_midden_in_het_plan_is_niet_voltooid(self): + """Stop je vóór een machine-stap, dan is het werk niet af: geen volmaak.""" + profiel = {'stappen': [self.stap, + {'id': 'stap-9', 'commando': 'touch negen', + 'bewijs': {'type': 'file_exists', 'pad': 'negen'}}, + {'id': 'stap-10', 'mens_nodig': {'instructie': 'Controleer'}}]} + voeg_gebeurtenissen_toe(self.log, [ + {'stap': 'stap-2', 'status': 'geslaagd', 'bewijs': 'x', 'tijdstip': 'nu'}, + {'stap': 'stap-10', 'status': 'wacht_op_mens', 'bewijs': 'x', 'tijdstip': 'nu'}]) + self.assertEqual(uitkomst(self.log), 'wacht_op_mens') + self.assertFalse(machine_deel_voltooid(profiel, self.log)) + + def test_panic_is_gepauzeerd_en_niet_voltooid(self): + activeer_panic(self.doel, 'test') + self.assertFalse(voer_uit({'stappen': [self.stap]}, self.doel, self.log, None)) + self.assertEqual(uitkomst(self.log), 'gepauzeerd') + self.assertFalse(machine_deel_voltooid({'stappen': [self.stap]}, self.log)) + + def test_echt_falen_wint_van_een_wachtende_mens(self): + """Een gefaalde stap mag nooit als 'wacht op de mens' doorgaan.""" + voeg_gebeurtenissen_toe(self.log, [ + {'stap': 'stap-1', 'status': 'geslaagd', 'bewijs': 'x', 'tijdstip': 'nu'}, + {'stap': 'stap-2', 'status': 'wacht_op_mens', 'bewijs': 'x', 'tijdstip': 'nu'}, + {'stap': 'stap-3', 'status': 'gefaald', 'bewijs': 'x', 'tijdstip': 'nu'}]) + self.assertEqual(uitkomst(self.log), 'gefaald') diff --git a/tests/test_gegevensroute.py b/tests/test_gegevensroute.py new file mode 100644 index 0000000..c6f89ac --- /dev/null +++ b/tests/test_gegevensroute.py @@ -0,0 +1,145 @@ +"""Gegevensroute en cloudtoestemming (advies 6). + +Wat hier wordt vastgehouden: +- de route wordt afgeleid uit de commando's (lokaal / eigen VPS / cloud); +- verklaart een profiel minder dan zijn commando's doen, dan wint het zwaarste + én komt er een waarschuwing — geen stille keuze; +- een cloud-opdracht start nooit zonder jouw expliciete toestemming, en die + toestemming staat in de geschiedenis (ook als je hem intrekt). +""" +import tempfile +import unittest +from pathlib import Path +from unittest.mock import patch + +import adapter +from kern import growkit_opdrachten as op +from kern import growkit_route as route +from seed import laad_profielen + + +def profiel_van(naam: str) -> dict: + return next(p for p in laad_profielen() if p["profiel"] == naam) + + +def een_stap(commando: str) -> dict: + return {"stappen": [{"id": "s1", "commando": commando, + "bewijs": {"type": "file_exists", "pad": "x"}}]} + + +class RouteAfleiding(unittest.TestCase): + def test_zonder_extern_commando_is_de_route_lokaal(self): + zelf = route.route(een_stap("mkdir -p x")) + self.assertEqual(zelf["soort"], "lokaal") + self.assertEqual(zelf["verzendt"], []) + + def test_ssh_naar_eigen_server_is_eigen_vps(self): + uit = route.route(een_stap("ssh gast@mijn-server 'ls'")) + self.assertEqual(uit["soort"], "eigen_vps") + self.assertTrue(uit["verzendt"]) + + def test_http_is_cloud(self): + self.assertEqual(route.route(een_stap("curl https://api.voorbeeld.nl/v1"))["soort"], "cloud") + + def test_cloud_wint_van_eigen_vps(self): + profiel = {"stappen": [{"id": "a", "commando": "ssh gast@vps 'x'"}, + {"id": "b", "commando": "wget https://x.nl"}]} + self.assertEqual(route.route(profiel)["soort"], "cloud") + + def test_lichter_verklaard_dan_gedaan_wordt_gemeld(self): + profiel = een_stap("curl https://api.voorbeeld.nl/v1") + profiel["gegevensroute"] = {"soort": "lokaal", "uitleg": "zegt lokaal"} + uit = route.route(profiel) + self.assertEqual(uit["soort"], "cloud") # zwaarste wint + self.assertIn("maar een commando gaat verder", uit["waarschuwing"]) + + def test_zwaarder_verklaren_mag_zonder_waarschuwing(self): + profiel = een_stap("mkdir -p x") + profiel["gegevensroute"] = {"soort": "cloud", "uitleg": "voorzichtig"} + uit = route.route(profiel) + self.assertEqual(uit["soort"], "cloud") + self.assertIsNone(uit["waarschuwing"]) + + def test_alle_bestaande_profielen_zijn_lokaal_en_verzenden_niets(self): + for naam in ("projectcontrole", "documentenoverzicht", "terugkerend-rapport", + "tweede-brein"): + uit = route.route(profiel_van(naam)) + self.assertEqual(uit["soort"], "lokaal", naam) + self.assertEqual(uit["verzendt"], [], naam) + self.assertEqual(uit["bron"], "verklaard", naam) + + def test_uitgebreide_netwerksignalen_zijn_nooit_lokaal(self): + """Elk bekend netwerkcommando moet als extern worden herkend.""" + for commando in ("git push origin main", "git clone https://x.nl/r.git", + "git fetch --all", "pip install requests", + "npm install left-pad", "nc -l 1234", "ncat -l 1234", + "ftp server", "sftp gast@server", + "python -c 'import urllib.request'", + "python -c 'import requests'", + "ssh gast@server 'ls'", "scp bestand gast@server:/tmp", + "rsync -a . gast@server:/tmp"): + self.assertNotEqual(route.route(een_stap(commando))["soort"], "lokaal", commando) + + def test_hoofdletters_maken_niets_uit(self): + self.assertEqual(route.route(een_stap("SSH gast@server 'ls'"))["soort"], "eigen_vps") + self.assertEqual(route.route(een_stap("GIT PUSH origin main"))["soort"], "cloud") + + def test_woordgrens_voorkomt_valse_alarmen(self): + """'sync' is geen rsync en 'curling' is geen curl.""" + for commando in ("cat sync.json", "python3 -m json.tool macht.log", + "echo curling is een sport"): + self.assertEqual(route.route(een_stap(commando))["soort"], "lokaal", commando) + + +class CloudPoort(unittest.TestCase): + def setUp(self): + self.tmp = tempfile.TemporaryDirectory() + self.addCleanup(self.tmp.cleanup) + patch.object(op, "_root", return_value=Path(self.tmp.name)).start() + self.addCleanup(patch.stopall) + self.profiel = { + "profiel": "cloud-demo", + "gegevensroute": {"soort": "cloud", "uitleg": "stuurt inhoud naar een clouddienst"}, + "stappen": [{"id": "s1", "commando": "touch bewijs.txt", + "bewijs": {"type": "file_exists", "pad": "bewijs.txt"}}], + } + + def _nieuw(self) -> dict: + return op.nieuw("Cloudproef", ["Het bewijs bestaat"], self.profiel) + + def test_zonder_toestemming_start_er_niets(self): + dossier = self._nieuw() + self.assertEqual(dossier["gegevensroute"]["soort"], "cloud") + self.assertFalse(dossier["cloud_toestemming"]) + with self.assertRaises(ValueError) as ctx: + op.uitvoeren(dossier["id"], dossier["plan_hash"], True) + self.assertIn("toestemming", str(ctx.exception)) + self.assertFalse((Path(dossier["doel"]) / "bewijs.txt").exists()) + + def test_met_toestemming_draait_het_en_staat_het_in_de_geschiedenis(self): + dossier = self._nieuw() + dossier = op.toestemming(dossier["id"], True, "Bewust via de cloud, deze opdracht") + self.assertTrue(dossier["cloud_toestemming"]) + dossier = op.uitvoeren(dossier["id"], dossier["plan_hash"], True) + self.assertEqual(dossier["status"], "resultaat") + self.assertIn("cloudtoestemming", [e["actie"] for e in dossier["geschiedenis"]]) + + def test_intrekken_werkt_en_blokkeert_weer(self): + dossier = self._nieuw() + dossier = op.toestemming(dossier["id"], True, "Eerste keer akkoord") + dossier = op.toestemming(dossier["id"], False, "Ik trek het in") + self.assertFalse(dossier["cloud_toestemming"]) + with self.assertRaises(ValueError): + op.uitvoeren(dossier["id"], dossier["plan_hash"], True) + + def test_toestemming_zonder_reden_is_geen_toestemming(self): + dossier = self._nieuw() + with self.assertRaises(ValueError): + op.toestemming(dossier["id"], True, " ") + + def test_adapteractie_toestemming_werkt(self): + dossier = self._nieuw() + uit = adapter.cmd_opdrachten({"actie": "toestemming", "id": dossier["id"], + "akkoord": True, "toelichting": "Bewust akkoord"}) + self.assertTrue(uit["ok"]) + self.assertTrue(uit["data"]["cloud_toestemming"]) diff --git a/tests/test_opdrachten.py b/tests/test_opdrachten.py new file mode 100644 index 0000000..05f51cc --- /dev/null +++ b/tests/test_opdrachten.py @@ -0,0 +1,58 @@ +import tempfile +import unittest +from pathlib import Path +from unittest.mock import patch +from kern import growkit_opdrachten as op + +class OpdrachtenTests(unittest.TestCase): + def setUp(self): + tmp = tempfile.TemporaryDirectory() + self.addCleanup(tmp.cleanup) + p = patch.object(op, '_root', return_value=Path(tmp.name)) + p.start(); self.addCleanup(p.stop) + self.profile = {'stappen': [{'id': 'a', 'commando': 'echo hi > result.txt', + 'verwacht': 'Resultaat bestaat', 'bewijs': {'type': 'file_exists', 'pad': 'result.txt'}}]} + + def test_full_lifecycle_and_no_accidental_rerun(self): + d = op.nieuw('Test', ['Resultaat klopt'], self.profile) + with self.assertRaises(ValueError): op.uitvoeren(d['id'], d['plan_hash']) + with self.assertRaises(ValueError): op.uitvoeren(d['id'], 'old', True) + d = op.uitvoeren(d['id'], d['plan_hash'], True) + self.assertEqual(d['status'], 'resultaat') + self.assertTrue(d['rapport']['technisch_gecontroleerd']) + self.assertFalse(d['rapport']['mens_goedgekeurd']) + with self.assertRaises(ValueError): op.uitvoeren(d['id'], d['plan_hash'], True) + d = op.beoordeel(d['id'], True, 'Bestand geopend en inhoud gecontroleerd') + self.assertEqual(d['status'], 'goedgekeurd') + self.assertEqual(op.lijst()['opdrachten'][0]['status'], 'goedgekeurd') + + def test_wait_approval_and_resume(self): + self.profile['stappen'].insert(0, {'id': 'mens', 'mens_nodig': {'instructie': 'Bevestig'}}) + d = op.nieuw('Test', ['Resultaat klopt'], self.profile) + d = op.uitvoeren(d['id'], d['plan_hash'], True) + self.assertEqual(d['status'], 'wacht_op_mens') + self.assertFalse((Path(d['doel']) / 'result.txt').exists()) + op.beoordeel(d['id'], True, 'Gecontroleerd') + d = op.uitvoeren(d['id'], d['plan_hash'], True) + self.assertEqual(d['status'], 'resultaat') + + def test_concurrent_execution_is_rejected(self): + d = op.nieuw('Test', ['ok'], self.profile) + with op._uitvoerslot(d['id']): + with self.assertRaises(ValueError): op.uitvoeren(d['id'], d['plan_hash'], True) + + def test_bad_id_cannot_escape_storage(self): + with self.assertRaises(ValueError): op.lees('../outside') + + def test_mislukte_stap_geeft_status_gefaald(self): + """Een commando dat na zijn alternatief faalt → 'gefaald', niet 'gepauzeerd'.""" + self.profile['stappen'] = [{'id': 'a', 'commando': 'false', + 'verwacht': 'Dit kan niet slagen', + 'bewijs': {'type': 'file_exists', 'pad': 'result.txt'}}] + d = op.nieuw('Mislukte opdracht', ['Resultaat klopt'], self.profile) + d = op.uitvoeren(d['id'], d['plan_hash'], True) + self.assertEqual(d['status'], 'gefaald') + self.assertEqual(op.lijst()['opdrachten'][0]['status'], 'gefaald') + # opnieuw proberen blijft mogelijk: 'gefaald' is geen eindstatus + d = op.uitvoeren(d['id'], d['plan_hash'], True) + self.assertEqual(d['status'], 'gefaald') diff --git a/tests/test_resultaat.py b/tests/test_resultaat.py new file mode 100644 index 0000000..db07122 --- /dev/null +++ b/tests/test_resultaat.py @@ -0,0 +1,27 @@ +import json +import tempfile +import unittest +from pathlib import Path +from kern.growkit_resultaat import bewijsrapport +from kern.growkit_bewijs import controleer + +class ResultaatTests(unittest.TestCase): + def test_machine_success_is_not_human_or_content_approval(self): + profile = {'acceptatiecriteria': ['Rapport klopt'], 'stappen': [{'id': 'a', 'verwacht': 'Bestand bestaat', 'bewijs': {'type': 'file_exists'}}]} + result = bewijsrapport(profile, [{'stap': 'a', 'status': 'geslaagd', 'bewijs': 'bestand bestaat'}]) + self.assertTrue(result['technisch_gecontroleerd']) + self.assertFalse(result['inhoudelijk_beoordeeld']) + self.assertFalse(result['mens_goedgekeurd']) + self.assertEqual(result['criteria'], ['Rapport klopt']) + + def test_later_failure_overrides_old_success(self): + r = bewijsrapport({'stappen': [{'id': 'a'}]}, [{'stap': 'a', 'status': 'geslaagd'}, {'stap': 'a', 'status': 'gefaald'}]) + self.assertFalse(r['technisch_gecontroleerd']) + + def test_structured_values_reject_wrong_value_and_type(self): + with tempfile.TemporaryDirectory() as tmp: + pad = Path(tmp) + check = {'type': 'json_valid', 'pad': 'report.json', 'verwacht_waarden': {'aantal': 1}} + for value, expected in [(1, True), (2, False), (True, False)]: + (pad / 'report.json').write_text(json.dumps({'aantal': value})) + self.assertEqual(controleer(check, pad)[0], expected) diff --git a/tests/test_storage_transactions.py b/tests/test_storage_transactions.py new file mode 100644 index 0000000..8878595 --- /dev/null +++ b/tests/test_storage_transactions.py @@ -0,0 +1,61 @@ +import json +import multiprocessing +import tempfile +import unittest +from pathlib import Path +from unittest.mock import patch +from kern.growkit_opslag import transactie, voeg_gebeurtenissen_toe +from kern import growkit_automatiek as am + + +def schrijf(pad, n): + for i in range(15): + voeg_gebeurtenissen_toe(Path(pad), [{'worker': n, 'i': i}]) + +class StorageTransactions(unittest.TestCase): + def setUp(self): + self.tmp = tempfile.TemporaryDirectory() + self.addCleanup(self.tmp.cleanup) + self.pad = Path(self.tmp.name) / 'log.json' + + def test_concurrent_processes_keep_every_event(self): + ctx = multiprocessing.get_context('spawn') + workers = [ctx.Process(target=schrijf, args=(str(self.pad), n)) for n in range(4)] + for p in workers: p.start() + for p in workers: + p.join(20) + self.assertEqual(p.exitcode, 0) + data = json.loads(self.pad.read_text()) + self.assertEqual(len({(x['worker'], x['i']) for x in data}), 60) + + def test_failed_commit_keeps_previous_snapshot(self): + voeg_gebeurtenissen_toe(self.pad, [{'old': True}]) + original = self.pad.read_bytes() + with patch('kern.growkit_opslag.os.replace', side_effect=OSError('disk failure')): + with self.assertRaises(OSError): + voeg_gebeurtenissen_toe(self.pad, [{'new': True}]) + self.assertEqual(self.pad.read_bytes(), original) + + def test_corruption_is_preserved_and_blocks_write(self): + self.pad.write_text('{broken') + with self.assertRaises(ValueError): + voeg_gebeurtenissen_toe(self.pad, [{'new': True}]) + self.assertEqual(self.pad.read_text(), '{broken') + + def test_history_cannot_be_edited(self): + voeg_gebeurtenissen_toe(self.pad, [{'old': True}]) + with self.assertRaises(ValueError): + with transactie(self.pad, append_only=True) as data: + data[0]['old'] = False + self.assertTrue(json.loads(self.pad.read_text())[0]['old']) + + def test_plan_and_history_committed_together_and_stale_edits_rejected(self): + with patch.object(am, '_opslag_pad', return_value=self.pad), patch.object(am, '_log_pad', return_value=self.pad.with_name('events.json')): + plan = am.voeg_toe('Test', am.nieuw_plan('Test')['blokken']) + stale = am.lees(plan['id']) + plan['titel'] = 'Changed' + am.bewaar(plan) + with self.assertRaises(ValueError): am.bewaar(stale) + state = json.loads(am._staat_pad().read_text()) + self.assertEqual(state['plannen'][0]['titel'], 'Changed') + self.assertEqual(len(state['gebeurtenissen']), 2) diff --git a/tests/test_voorbeelden.py b/tests/test_voorbeelden.py new file mode 100644 index 0000000..3f37fe2 --- /dev/null +++ b/tests/test_voorbeelden.py @@ -0,0 +1,138 @@ +"""De drie voorbeeldopdrachten (advies 5): lokaal, zonder VPS, met echt bewijs. + +Wat hier wordt vastgehouden: +- er zijn precies drie voorbeelden, elk met een eigen plan én een mens-stap; +- geen enkel voorbeeldcommando raakt een VPS of internet; +- elk voorbeeld draait echt van concept → bevestiging → uitvoering → bewijs → oordeel, + en levert de bestanden op die het belooft. +""" +import json +import tempfile +import unittest +from pathlib import Path +from unittest.mock import patch + +from kern import growkit_opdrachten as op +from kern import growkit_voorbeelden as vb +from kern.growkit_bewijs import BEWIJS_TYPES +from kern.growkit_motor import vervang_growkit_pad +from seed import laad_profielen + +REPO = Path(__file__).resolve().parents[1] +VERWACHT = ["documentenoverzicht", "projectcontrole", "terugkerend-rapport"] + + +def profiel_van(naam: str) -> dict: + return next(p for p in laad_profielen() if p["profiel"] == naam) + + +class VoorbeeldenContract(unittest.TestCase): + def test_precies_drie_voorbeelden_met_plan_en_mensstap(self): + voorbeelden = vb.voorbeelden() + self.assertEqual([v["id"] for v in voorbeelden], VERWACHT) + for v in voorbeelden: + self.assertTrue(v["titel"], v["id"]) + self.assertTrue(v["uitleg"], v["id"]) + self.assertTrue(v["criteria"], v["id"]) + self.assertGreaterEqual(v["stappen"], 3, v["id"]) + self.assertGreaterEqual(v["mens_stappen"], 1, v["id"]) + + def test_geen_enkel_voorbeeld_raakt_een_vps_of_internet(self): + for profiel in vb.voorbeeld_profielen(): + self.assertEqual(vb.externe_aanroepen(profiel), [], profiel["profiel"]) + + def test_elk_bewijs_is_een_bekend_type(self): + for profiel in vb.voorbeeld_profielen(): + for stap in profiel["stappen"]: + if stap.get("mens_nodig"): + continue + self.assertIn(stap["bewijs"]["type"], BEWIJS_TYPES, + f"{profiel['profiel']}/{stap['id']}") + + def test_voorbeelden_staan_niet_in_de_bewezen_profielenlijst(self): + """Een voorbeeld is geen bewezen vorm: de picker blijft eerlijk.""" + from seed import laad_profielen as laad + self.assertEqual([p["profiel"] for p in laad() if p.get("status") == "voorbeeld"], + VERWACHT) + + +class VoorbeeldenUitvoering(unittest.TestCase): + """Elk voorbeeld draait echt door de kern, in een eigen tijdelijke map.""" + + def setUp(self): + self.tmp = tempfile.TemporaryDirectory() + self.addCleanup(self.tmp.cleanup) + patch.object(op, "_root", return_value=Path(self.tmp.name)).start() + self.addCleanup(patch.stopall) + + def _draai(self, naam: str) -> tuple[dict, Path]: + profiel = vervang_growkit_pad(profiel_van(naam), REPO) + criteria = profiel["voorbeeld"]["criteria"] + dossier = op.nieuw(profiel["voorbeeld"]["titel"], criteria, profiel, + REPO / "profielen" / naam / "sjablonen") + with self.assertRaises(ValueError): + op.uitvoeren(dossier["id"], dossier["plan_hash"]) # zonder bevestiging + dossier = op.uitvoeren(dossier["id"], dossier["plan_hash"], True) + return dossier, Path(dossier["doel"]) + + def test_elk_voorbeeld_levert_bestand_bewijs_en_mensmoment(self): + verwachte_bestanden = { + "documentenoverzicht": ["overzicht/overzicht.md", "overzicht/markdown-aantal.txt", + "overzicht/markdown-lijst.txt"], + "projectcontrole": ["controle/controle.md", "controle/kernbestanden.txt", + "controle/basis.txt"], + "terugkerend-rapport": ["rapport/rapport.md", "rapport/datum.txt", + "rapport/scriptbestanden.txt"], + } + for naam in VERWACHT: + dossier, doel = self._draai(naam) + self.assertEqual(dossier["status"], "wacht_op_mens", naam) + self.assertTrue(dossier["rapport"]["technisch_gecontroleerd"], naam) + self.assertFalse(dossier["rapport"]["mens_goedgekeurd"], naam) + machine = [s for s in dossier["rapport"]["stappen"] + if s.get("controle") != "mens_verificatie"] + self.assertTrue(machine, naam) + self.assertTrue(all(s["technisch"] == "geslaagd" for s in machine), + f"{naam}: {machine}") + for bestand in verwachte_bestanden[naam]: + self.assertTrue((doel / bestand).exists(), f"{naam}: {bestand} ontbreekt") + # en dan beslist de mens — geen automatische goedkeuring + dossier = op.beoordeel(dossier["id"], True, "Nagekeken en akkoord") + self.assertEqual(dossier["status"], "goedgekeurd", naam) + # het eindresultaat is vastgelegd als acceptatie (apart van stap-bewijs); + # de stap-voor-stap 'mens'-kolom blijft bewust 'niet_goedgekeurd' voor + # machine-stappen — dat is precies het onderscheid van advies 3. + logboek = json.loads((doel / "logboek.json").read_text(encoding="utf-8")) + self.assertIn("goedgekeurd", + [e.get("status") for e in logboek if e.get("type") == "acceptatie"], naam) + + def test_afwijzen_geeft_geen_goedkeuring(self): + """Afwijzen bij het mens-moment zet de stap op herziening, niet op akkoord.""" + dossier, doel = self._draai("projectcontrole") + dossier = op.beoordeel(dossier["id"], False, "Het rapport mist de bronvermelding") + self.assertEqual(dossier["status"], "gepauzeerd") + self.assertFalse(dossier["rapport"]["mens_goedgekeurd"]) + logboek = json.loads((doel / "logboek.json").read_text(encoding="utf-8")) + self.assertIn("herziening_nodig", [e.get("status") for e in logboek]) + + +class VoorbeeldenViaAdapter(unittest.TestCase): + """De app haalt de voorbeelden op via de adapter — geen tweede lijst in Swift.""" + + def test_adapteractie_voorbeelden_geeft_de_drie_met_plan(self): + import adapter + + uit = adapter.cmd_opdrachten({"actie": "voorbeelden"}) + self.assertTrue(uit["ok"]) + voorbeelden = uit["data"]["voorbeelden"] + self.assertEqual([v["id"] for v in voorbeelden], VERWACHT) + for v in voorbeelden: + self.assertTrue(v["titel"] and v["criteria"], v["id"]) + # het profiel dat de app straks aan 'nieuw' meegeeft, moet echt bestaan + self.assertEqual(profiel_van(v["profiel"])["profiel"], v["profiel"]) + + def test_onbekende_actie_blijft_een_nette_fout(self): + import adapter + + with self.assertRaises(adapter.AdapterFout): + adapter.cmd_opdrachten({"actie": "bestaat-niet"})