@arkvenai/cli 0.5.1

package/CHANGELOG.md

@@ -0,0 +1,105 @@
+# Änderungen
+
+## 0.5.1 - 2026-08-26
+
+### Geändert
+
+- **README und Paket-Beschreibung sagen jetzt zuerst, was zu tun ist.** Oben stehen die zwei
+  Wege als nummerierte Schritte: `login` → `pull` → ändern → `push` → `push --deploy` für eine
+  App, die es in Arkven schon gibt, und `login` → `init` → `push` → `push --deploy` für ein
+  Projekt vom eigenen Rechner. Die Befehlsteile darunter erklären die Schalter, nicht mehr den
+  Einstieg.
+- **`arkven help` zeigt denselben Rundlauf** vor der Befehlsliste.
+- Zwei veraltete Aussagen sind aus der README verschwunden: „angekündigt und noch nicht
+  enthalten: `mcp`" (`arkven mcp` gibt es seit 0.5.0) und „die Gates der Plattform laufen hier
+  nicht mit" (`check --tief` und `push` fahren sie).
+
+## 0.5.0 — 2026-08-25
+
+### Neu
+
+- **`arkven pull` braucht keinen vorherigen `push` mehr.** Kennt der Ordner noch kein Projekt,
+  zeigt `pull` die Projekte deiner Teams und fragt, welches gemeint ist. `--projekt=<kennung>`
+  beantwortet die Frage vorweg. Ohne Terminal wird nicht geraten: die Liste wird ausgegeben und
+  der Schalter genannt.
+
+  Vorher las `pull` die Kennung aus `arkven.json`, und dorthin schrieb sie nur `push`. Wer seine
+  App **in** Arkven gebaut hat, haette also erst pushen muessen, um ziehen zu duerfen, und ein
+  `push` aus einem leeren Ordner ersetzt die lebende App durch nichts. Der Rueckweg braucht
+  keinen Hinweg.
+
+- **Das Layout kommt aus dem Projekt.** Nach der Auswahl traegt `pull` die `arkven.json` des
+  Projekts nach und legt die darin genannten Ordner an, bevor er ablegt. Ein leeres Verzeichnis
+  bekommt damit den Baum, den ein spaeterer `push` wieder erwartet, statt eines flachen.
+
+### Behoben
+
+- **Die Deklaration landete im falschen Ordner.** `push` holt `arkven.json`,
+  `arkven/bauplan.json`, `arkven/auftrag.md` und `arkven/mails/*.md` aus der Projektwurzel;
+  `pull` legte sie in den Frontend-Ordner. In einem echten Projekt (487 Dateien) lagen dadurch
+  ein Bauplan und vier Mail-Vorlagen doppelt, mit verschiedenem Inhalt, und der naechste `push`
+  haette die gezogene Fassung an dieser Stelle nicht wieder eingesammelt. Jetzt gilt beidseitig
+  dieselbe Grenze.
+
+### Bekannt und noch offen
+
+- **Der Selbstabgleich am Ende von `npm run veroeffentlichen` misst die zweite Tuer nicht.** Er
+  ruft das Packument ohne Ausweis ab; GitHub Packages antwortet darauf nicht, und der Lauf liest
+  das als „keine Fassung da". Nach einem erfolgreichen Upload meldet er deshalb trotzdem einen
+  Fehlschlag.
+
+- **Dokumente kommen nicht mit.** `pull` meldet dazu „dieser Zugang deckt den Bereich Dokumente
+  nicht ab". Der Server lehnt in Wahrheit ab, weil der Aufruf ohne Team-Angabe geht. Der Rest des
+  Laufs ist davon unberuehrt und vollstaendig geschrieben.
+- **Bauplan und Mail-Vorlagen haben zwei Quellen** (Deklaration und Code-Stand). Sie kollidieren
+  jetzt sichtbar in der Vorschau, statt still auseinanderzulaufen; der Code-Stand gewinnt.
+
+## 0.4.0 — 2026-08-03
+
+Diese Fassung entstand beim ersten echten Live-Gang eines mitgebrachten Projekts. Jeder Punkt unten
+ist ein gemessener Fehlschlag, kein Wunsch.
+
+### Neu
+
+- **Bilder, Videos und Schriften reisen mit.** Vorher liess `push` sie weg (Binaerdateien und alles
+  ueber 1 MB) und sagte das auch — und die App ging mit kaputten Bildern live. Sie gehen jetzt einen
+  eigenen Weg, einzeln, und nur was sich geaendert hat.
+- **`arkven pull`** — der Rueckweg. Holt Bauplan und Auftrag aus Arkven ins Projekt. Zeigt erst, was
+  sich aendern wuerde, dann schreibt es.
+- **`arkven check --tief`** — die ECHTEN Gates der Plattform laufen mit, dieselbe Pruefung wie beim
+  Ausrollen. Nicht nachgebaut: der Baum geht an Arkven, dort laeuft `verifyBackend`.
+- **`push` faehrt sie ebenfalls.** Ein blockierender Punkt haelt die Uebertragung an, BEVOR eine
+  Datei reist.
+- **Bauplan und Auftrag im Repo** (`arkven/bauplan.json`, `arkven/auftrag.md`). Sie reisen mit und
+  erscheinen im Cockpit; `check` prueft sie lokal, bevor sie reisen.
+- **Eigene Mail-Vorlagen** (`arkven/mails/<key>.md`) — nur die geaenderten. Der Plattform-Standard
+  bleibt in Arkven.
+- **`braucht`** in `arkven.json`: welche Dienste das Projekt benoetigt. Ergaenzt die Messung am Code,
+  ersetzt sie nicht.
+- **Die Anker werden geprueft** — `arkven/anker-fehlt`, `anker-doppelt`, `anker-unbekannt`. Sie
+  beantworten „warum steht im Cockpit 0 von 9", bevor jemand fragen muss: mit Screen-Name, Adresse
+  und der exakten Kennung, die ins Wurzelelement gehoert. Die Kennungen kommen aus Arkven, sie werden
+  nicht nachgerechnet.
+- **`arkven fix` setzt sie auch.** Anker halten nichts auf, deshalb fielen sie vorher aus dem
+  Agenten-Auftrag heraus — `fix` konnte genau das nicht beheben, wofuer die Regeln geschrieben
+  wurden. Sie stehen jetzt im Auftrag, getrennt von den blockierenden Punkten, samt dem Fallstrick:
+  gibt die Komponente ein Fragment zurueck, braucht der Traeger `display: contents`.
+- **`arkven/mail-unbekannt`** — ein Tippfehler im Dateinamen erzeugte bisher eine Vorlage, die
+  niemand je verschickt. Sie lag im Repo, sah gepflegt aus, und die echte blieb auf dem
+  Plattform-Standard. Der Vorschlag rechnet echte Aehnlichkeit; ab zwei Zeichen Unterschied wird die
+  Liste genannt statt geraten.
+- **`--sarif`** — dieselben Befunde in der Form, die GitHub Code-Scanning, VS Code und CI schon
+  lesen. Damit erscheint ein Befund an der Zeile im Pull-Request. `ungeprueft` wird dabei NICHT zu
+  einem kleinen Mangel verkleinert, sondern steht als `kind: open` da: gelaufen, kein Urteil.
+
+### Behoben
+
+- `push --deploy` tat nichts, wenn es nichts zu uebertragen gab — genau der haeufigste Fall nach
+  einem gescheiterten Deploy.
+- Das Ausrollen scheiterte mit 401, obwohl die Uebertragung mit demselben Token gelang.
+
+### Hinweis
+
+Der Bauplan bestimmt, was im Cockpit als „gebaut" gilt. Damit ein Screen zaehlt, traegt sein
+Wurzelelement `data-arkven-screen="scr-N"`. Ohne diesen Anker bleibt er offen, auch wenn er laengst
+funktioniert.

package/README.md

@@ -0,0 +1,304 @@
+# @arkvenai/cli
+
+Dein Arkven-Projekt auf diesem Rechner: anmelden, holen, ändern, zurückstellen, online stellen.
+
+```bash
+npm install -g @arkvenai/cli
+arkven login
+```
+
+Ohne Installation läuft jeder Befehl auch als `npx @arkvenai/cli <befehl>`.
+
+---
+
+## Weg 1: eine App, die es in Arkven schon gibt
+
+Der Normalfall. Du hast im Cockpit gebaut und willst lokal weiterarbeiten.
+
+```bash
+arkven login                  # 1. einmal pro Rechner
+mkdir meine-app && cd meine-app
+arkven pull                   # 2. zeigt deine Projekte, du wählst die Nummer
+                              # 3. Änderungen machen: Editor, Agent, wie du willst
+arkven push                   # 4. Vorschau ansehen und bestätigen
+arkven push --deploy          # 5. online stellen
+```
+
+**Schritt 2 sieht so aus:**
+
+```
+$ arkven pull
+
+Dieser Ordner kennt noch kein Projekt. Deine Projekte:
+
+   1  Mein Laden                        live   zuletzt 25.08.2026
+      sess_cf86fd83-6f68-45fa-8c9d-0399a3eb6caf
+   2  Touren-Planer                            zuletzt 20.08.2026
+      sess_9rxa9vk
+
+Welches Projekt? [1-2] >
+```
+
+Danach steht die Kennung in `arkven.json`, und jeder weitere `pull` und `push` in diesem Ordner
+meint dieses Projekt. Ohne Rückfrage: `arkven pull --projekt=<kennung>`.
+
+Von da an ist der Rundlauf immer derselbe: **ändern, `arkven push`, `arkven push --deploy`.**
+
+---
+
+## Weg 2: ein Projekt, das auf deinem Rechner entstanden ist
+
+```bash
+arkven login                        # 1. einmal pro Rechner
+cd mein-projekt
+arkven init                         # 2. schreibt arkven.json
+arkven push --name="Mein Tool"      # 3. legt das Projekt in Arkven an
+arkven push --deploy                # 4. online stellen
+```
+
+Ab dem zweiten Mal genügen `arkven push` und `arkven push --deploy`: Name und Kennung stehen dann in
+`arkven.json`.
+
+Ganz von vorn: `arkven new meine-app` legt ein Projekt an, das die Anforderungen des Containers
+schon erfüllt.
+
+---
+
+## Die Befehle
+
+| Befehl | Was er tut |
+|---|---|
+| `arkven login` | Meldet diesen Rechner an deinem Arkven-Konto an |
+| `arkven pull` | Holt ein Projekt aus Arkven in diesen Ordner |
+| `arkven push` | Stellt deinen Stand zurück nach Arkven |
+| `arkven push --deploy` | Rollt danach aus und zeigt den Lauf mit |
+| `arkven init` | Erkennt, was dein Projekt mitbringt, und schreibt `arkven.json` |
+| `arkven new <name>` | Legt ein neues Projekt an, das den Container-Vertrag schon erfüllt |
+| `arkven check` | Prüft dein Projekt, so oft du willst |
+| `arkven fix` | Übergibt die Befunde dem lokalen Claude Code und misst danach erneut |
+| `arkven mcp` | Meldet `check`, `auftrag` und `pull` als MCP-Werkzeuge an |
+
+`arkven help` zeigt dieselbe Übersicht mit allen Schaltern.
+
+---
+
+## `arkven login`
+
+```bash
+arkven login                        # Standard: https://app.arkven.de
+arkven login --server=<adresse>     # eigene Installation
+arkven login --einfuegen            # wenn dieser Rechner den Server nicht erreicht
+```
+
+Der Browser bestätigt, das Token landet im Benutzerverzeichnis (`~/.arkven/zugang.json`), nie im
+Projekt. Die Standard-Adresse ist `app.arkven.de` und nicht `arkven.de`: unter der bloßen Domain
+liegt die Marketing-Seite, die Anwendung samt API liegt unter `app.`.
+
+`login` richtet auch den Paketbezug ein, danach funktioniert `npm install @arkvenai/base` in diesem
+Projekt.
+
+## `arkven pull`
+
+```bash
+arkven pull                          # zeigt deine Projekte und fragt, welches
+arkven pull --projekt=<kennung>      # ohne Rückfrage, für Skripte
+arkven pull --yes                    # bestätigt die Vorschau ungesehen
+arkven pull --nur-deklaration        # ohne Code: Bauplan, Auftrag, Nachweis, Mail-Vorlagen
+```
+
+Ein leeres Verzeichnis genügt. Du musst vorher **nicht** gepusht haben. Sitzt niemand am Terminal,
+wird nicht geraten, sondern die Liste ausgegeben und `--projekt=` genannt.
+
+Wo Server und Oberfläche liegen, sagt das Projekt selbst: `pull` trägt seine `arkven.json` nach,
+bevor er ablegt, und legt die genannten Ordner an. Damit bekommst du den Baum, den ein späterer
+`push` wieder erwartet.
+
+**Es wird nie etwas gelöscht.** Dateien, die nur bei dir liegen, bleiben unberührt. Was
+überschrieben würde, steht einzeln in der Vorschau, bevor irgendetwas passiert.
+
+## `arkven push`
+
+```bash
+arkven push                      # zeigt die Vorschau und fragt
+arkven push --deploy             # danach ausrollen und den Lauf mitlesen
+arkven push --yes                # bestätigt sie ungesehen (CI, Agenten)
+arkven push --name="Mein Tool"   # der Anzeigename beim ersten Mal
+```
+
+Die Reihenfolge ist die Aussage:
+
+1. **Geprüft wird zuerst.** Was den Container-Vertrag nicht hält, wird benannt und nicht
+   übertragen. Die Gates der Plattform laufen dabei mit, dieselbe Prüfung wie beim Ausrollen.
+2. **Gesammelt wird nur Quelltext.** Versteckte Einträge bleiben liegen, also auch `.env` und
+   `.git`: Zugangsdaten verlassen deinen Rechner nicht. Erzeugte Ordner (`node_modules`, `dist`,
+   `build`, `coverage`) ebenfalls nicht. Was ausgelassen wurde, sagt der Lauf mit Zahl.
+3. **Vorschau vor dem Schreiben.**
+
+```
+Vorschau für „Rechnungstool" (sess_a8jan2i)
+
+    14 neu           (in deinem Verzeichnis, in Arkven noch nicht)
+     3 aktualisiert  (du hast sie geändert, Arkven nicht)
+    84 unberuehrt    (in Arkven ändert sich daran nichts)
+```
+
+**Bei einem Konflikt bricht `push` ab und nennt die Dateien.** Es gibt bewusst kein `--force`, und
+auch `--yes` löst keinen Konflikt auf: eine automatische Wahl würde eine der beiden Fassungen still
+verlieren, und das sähe aus wie ein gelungener Push.
+
+Ein Push löscht nichts, was nur Arkven kennt: der erzeugte Server bleibt stehen. Ein abgebrochener
+Lauf (Strg-C, Netz weg) hinterlässt kein halbes Projekt, angelegt wird erst nach vollständiger
+Übertragung.
+
+`--deploy` ruft dieselbe Route wie die Oberfläche und mit derselben Rollenprüfung. Scheitert der
+Lauf, steht die **erste** Fehlerzeile oben, und dein Code bleibt übertragen.
+
+### Der Name wird nicht geraten
+
+Beim ersten Push heißt das Projekt so, wie `--name` es sagt; ohne die Angabe gilt der `name` aus
+der `package.json` der Projektwurzel, danach der Name der Wurzel selbst. Sagt keiner davon etwas
+über das Projekt (`server`, `app`, `src` …), wird gefragt. Gibt es kein Terminal, bricht der Lauf ab
+und nennt `--name` als Weg. Aus einem Ordnernamen wurde schon einmal ein Projekt namens „server".
+
+### Zwei Teile: Server und Frontend in getrennten Ordnern
+
+Arkven hält ein Projekt an **zwei** Orten, und sie haben verschiedene Aufgaben: aus dem
+Frontend-Teil entstehen Vorschau und Frontend-Bau, der Server-Teil geht in den Container. Liegen
+beide bei dir in eigenen Ordnern, sagt das `arkven.json`:
+
+```jsonc
+{
+  "verzeichnisse": {
+    "server": "server",   // geht in den Container
+    "frontend": "web"     // wird die Vorschau
+  }
+}
+```
+
+Beide Angaben sind optional und relativ zur Projektwurzel. Ohne sie ist die Projektwurzel der eine
+Baum. Mit der Angabe gilt:
+
+- **Beide Bäume werden gesammelt**, jeder mit Pfaden relativ zu seinem Verzeichnis: aus
+  `web/src/App.tsx` wird `/src/App.tsx` in der App, aus `server/src/index.ts` wird `src/index.ts`
+  im Server-Quelltext. Der Bericht sagt vor dem Schreiben, welche Datei wohin geht.
+- **Geprüft wird der Server-Teil**, nicht die Wurzel.
+- **`arkven.json` reist mit dem Frontend-Teil.** Der Bau liest deine `mitgebracht`-Angaben dort;
+  ohne diesen Schritt käme deine eigene `tailwind.config.js` unter das Scaffold.
+- **Was außerhalb beider Ordner liegt, kommt nicht mit** und wird beim Namen genannt. Braucht ein
+  Teil einen gemeinsamen `shared/`-Ordner, muss er innerhalb seines Verzeichnisses liegen.
+
+Ein Verzeichnis, das es nicht gibt, bricht den Lauf ab, statt still auf „ein Baum" zurückzufallen:
+genau dieser stille Rückfall hat am 2026-08-01 einen Express-Server in die Frontend-Vorschau
+gelegt. Das Ergebnis war eine leere Seite und die Frage „wo ist mein Frontend?".
+
+## `arkven init`
+
+`init` liest, was da ist (`package.json`, Lockfile, eigener Server, `drizzle/`-Historie,
+Build-Setup) und schreibt **eine** Datei: `arkven.json`.
+
+```jsonc
+{
+  "$schema": "https://app.arkven.de/schema/arkven.json",
+  "mitgebracht": {
+    "server": true,         // Arkven ergänzt, es scaffoldet nicht
+    "frontendBuild": false, // tailwind/postcss/vite bleiben deine
+    "schema": true          // deine Migrationen gewinnen
+  }
+}
+```
+
+**Was nicht sicher erkennbar ist, wird gefragt**, mit Vorschlag, nie geraten. Gibt es kein Terminal
+(Skript, CI, Pipe), bleibt das Feld aus der Datei heraus und der Lauf sagt, welches und warum. Ein
+geratenes `server: true` hieße später: Arkven ergänzt einen Server, den es nie gab.
+
+**Was fehlt, kommt als Diff zum Bestätigen**, nie als stille Schreibaktion: eine
+`schemaGate.ts`-Vorlage, `tsx`/`drizzle-kit` in den `dependencies`, `.gitignore`-Einträge.
+`arkven init --apply` übernimmt die Datei-Vorschläge gesammelt. Alles, was Pakete aus dem Netz holt,
+bleibt ein Befehl für dich.
+
+Die Datei gehört dir. Steht ein Feld schon drin, bleibt es stehen, auch wenn die Messung etwas
+anderes sagt; der Unterschied wird benannt statt überschrieben. Ein zweiter Lauf ändert nichts, was
+der erste richtig gemacht hat, und formatiert deine `package.json` nicht um.
+
+## `arkven new`
+
+```bash
+arkven new meine-app
+cd meine-app && npm install
+```
+
+Legt 15 Dateien an und misst danach selbst nach: **9 gehalten, 0 blockierend**, bevor die erste
+eigene Zeile geschrieben ist.
+
+| Was | Wo | Wogegen es hilft |
+|---|---|---|
+| Einstieg mit Härtungs-Prüfung beim Start | `src/index.ts` | Fällt ein Pflicht-Header beim Umbau heraus, bricht der Start ab, statt still ungehärtet zu laufen |
+| Wächter gegen die laufende Datenbank | `src/schemaGate.ts` | Eine Migration kann mit Rückgabewert 0 enden, ohne dass das Schema steht |
+| Eine Egress-Naht mit Host-Allowlist | `src/lib/egress.ts` | „Mit wem redet diese App?" hat genau eine Antwort |
+| Härtung ohne Importe | `src/http/sicherheitsHeader.ts` | Läge sie im Einstieg, entstünde ein Import-Zyklus über die Middleware |
+| Migration **und** Journal | `drizzle/` | Ohne Journal legt der Container das Schema neu an, statt zu migrieren |
+| `tsx` und `drizzle-kit` in `dependencies` | `package.json` | Der Container installiert nur `dependencies` |
+
+`arkven.json` entsteht dabei über dieselbe Erkennung wie bei `init`, nicht über eine zweite Regel.
+
+**Es wird nie etwas überschrieben.** Liegt im Zielverzeichnis schon etwas, bricht der Lauf ab und
+nennt beide Auswege (anderer Name oder `arkven init`). Ein leeres Verzeichnis darf er benutzen.
+
+## `arkven check`
+
+```bash
+arkven check           # lokal, in Sekunden
+arkven check --tief    # die Gates der Plattform laufen mit (braucht Anmeldung)
+arkven check --json    # stabile Regel-Kennungen, für Agenten
+arkven check --sarif   # SARIF 2.1.0 für GitHub Code-Scanning, VS Code und CI
+```
+
+Jeder Befund nennt Datei, Regel und Ausweg. Geprüft wird:
+
+| Regel | Was gilt |
+|---|---|
+| `arkven/ein-paket` | Das Verzeichnis ist ein Paket, kein Verbund aus mehreren |
+| `arkven/einstieg` | `src/index.ts` ist der Einstiegspunkt |
+| `arkven/port-aus-umgebung` | Der Port kommt aus `process.env.PORT` |
+| `arkven/datenbank-aus-umgebung` | Die Verbindung kommt aus `process.env.DATABASE_URL` |
+| `arkven/keine-workspaces` | Eine `package.json`, keine Workspace-Verweise |
+| `arkven/importe-aufloesbar` | Jeder Import zeigt auf ein Paket, das im Container existiert |
+| `arkven/laufzeit-tsx` · `arkven/laufzeit-drizzle-kit` | Beide stehen in `dependencies`, nicht in `devDependencies` |
+| `arkven/schema-waechter` | `src/schemaGate.ts` prüft das Schema gegen die laufende Datenbank |
+
+Dazu zwei Hinweise, die nicht blockieren: ein fehlendes Migrations-Journal
+(`arkven/migrations-journal`) und fehlender Baustein-Bezug (`arkven/paketbezug`).
+
+**Monorepos:** Zeigst du auf ein Verzeichnis mit mehreren Paketen, meldet der Lauf **eine** Sache
+statt sieben: der Container macht genau ein Paket zur App, also ist erst zu klären, welches. Die
+übrigen Punkte erscheinen als „nicht geprüft", nicht als verletzt. Der Ausweg nennt die Kandidaten.
+
+## `arkven fix`
+
+```bash
+arkven fix              # höchstens 3 Durchgänge, `--runden N` für mehr
+arkven auftrag          # gibt nur die Arbeitsanweisung aus, ohne etwas zu tun
+```
+
+`fix` baut aus jedem blockierenden Befund einen Auftrag und übergibt ihn dem **lokal installierten
+Claude Code** (dessen Konto, dessen Rechte, dessen Abrechnung, kein eigener Schlüssel). Danach misst
+es erneut.
+
+Die tragende Regel: **behoben ist nur, was der erneute Lauf misst.** Die Erfolgsmeldung des Agenten
+zählt nichts. Bringt eine Runde keinen einzigen Punkt weiter, hört `fix` auf, statt dieselbe
+Anweisung zu wiederholen. Es committet nichts und pusht nichts; die Änderungen liegen als `git diff`
+zur Durchsicht. Ist kein `claude` installiert, sagt `fix` das und nennt den Weg.
+
+---
+
+## Rückgabewerte
+
+| Befehl | `0` | `1` | `2` |
+|---|---|---|---|
+| `check` | alles gehalten | mindestens ein blockierender Punkt | nichts messbar |
+| `init` | alles geklärt | etwas bleibt zu entscheiden | nichts messbar |
+| `new` | angelegt und nachgemessen | abgebrochen, nichts angelegt | |
+| `push` | übernommen | Befund oder Konflikt | nichts messbar |
+
+`--json` liefert dieselben Befunde mit stabilen Regel-Kennungen, damit ein Agent ohne Textanalyse
+handeln kann.

package/dist/agents.d.ts

@@ -0,0 +1,11 @@
+export declare const MARKE_START = "<!-- arkven:start \u00B7 dieser Block wird von `arkven init` gepflegt -->";
+export declare const MARKE_START_ALT = "<!-- arkven:start \u2014 dieser Block wird von `arkven init` gepflegt -->";
+export declare const MARKE_ENDE = "<!-- arkven:ende -->";
+export interface AgentsLage {
+    eigenerServer: boolean;
+    eigenerFrontendBau: boolean;
+    eigenesSchema: boolean;
+}
+export declare function agentsBlock(lage: AgentsLage): string;
+export declare function agentsNachher(vorher: string | undefined, lage: AgentsLage): string | undefined;
+//# sourceMappingURL=agents.d.ts.map

package/dist/agents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agents.d.ts","sourceRoot":"","sources":["../src/agents.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,WAAW,8EAAyE,CAAA;AAEjG,eAAO,MAAM,eAAe,8EAAyE,CAAA;AACrG,eAAO,MAAM,UAAU,yBAAyB,CAAA;AAEhD,MAAM,WAAW,UAAU;IAEzB,aAAa,EAAE,OAAO,CAAA;IAEtB,kBAAkB,EAAE,OAAO,CAAA;IAE3B,aAAa,EAAE,OAAO,CAAA;CACvB;AAsBD,wBAAgB,WAAW,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CA4CpD;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,GAAG,SAAS,CAiB9F"}

package/dist/agents.js

@@ -0,0 +1,76 @@
+export const MARKE_START = '<!-- arkven:start · dieser Block wird von `arkven init` gepflegt -->';
+export const MARKE_START_ALT = '<!-- arkven:start — dieser Block wird von `arkven init` gepflegt -->';
+export const MARKE_ENDE = '<!-- arkven:ende -->';
+function herkunftsZeilen(lage) {
+    const zeilen = [];
+    zeilen.push(lage.eigenerServer
+        ? '- **Der Server gehört diesem Projekt.** Arkven erzeugt hier nichts nach und überschreibt nichts. Was im Server-Verzeichnis steht, hast du geschrieben.'
+        : '- **Den Server stellt Arkven.** Er wird bei jedem Ausrollen neu erzeugt. Änderungen daran gehen beim nächsten Lauf verloren, ohne Meldung.');
+    zeilen.push(lage.eigenerFrontendBau
+        ? '- **Den Frontend-Bau führt dieses Projekt selbst.** Deine Bau-Konfiguration bleibt unberührt.'
+        : '- **Den Frontend-Bau stellt Arkven** (vite). Eine eigene Bau-Konfiguration hier wirkt nicht.');
+    zeilen.push(lage.eigenesSchema
+        ? '- **Die Migrationen gehören diesem Projekt.** Sie gewinnen gegen erzeugte. `drizzle/meta/_journal.json` muss mitreisen, sonst läuft keine einzige SQL-Datei.'
+        : '- **Die Migrationen erzeugt Arkven** aus dem Schema. Handgeschriebenes SQL hier wird nicht ausgeführt.');
+    return zeilen;
+}
+export function agentsBlock(lage) {
+    return [
+        MARKE_START,
+        '',
+        '## Diese App läuft auf Arkven',
+        '',
+        'Arkven baut die App in einen Container und prüft sie vor dem Veröffentlichen. Was diese Prüfung',
+        'nicht besteht, geht nicht live. Die Regeln unten sind deshalb keine Empfehlungen.',
+        '',
+        '### Was dir gehört und was Arkven stellt',
+        '',
+        ...herkunftsZeilen(lage),
+        '',
+        '### Die Befehle',
+        '',
+        '```bash',
+        'arkven check          # prüft dieses Verzeichnis gegen den Container-Vertrag (kein Netz nötig)',
+        'arkven check --json   # dasselbe maschinenlesbar, mit stabilen Regel-Kennungen',
+        'arkven check --tief   # zusätzlich die echten Tore der Plattform (braucht `arkven login`)',
+        'arkven push           # zeigt erst, was passieren würde, und überträgt es dann',
+        '```',
+        '',
+        '`arkven check` ist die Abnahme. Wenn du eine Änderung für fertig hältst, ist sie es, sobald',
+        'dieser Lauf grün ist, nicht vorher und nicht, weil sie plausibel aussieht.',
+        '',
+        '### Was du nicht anfassen darfst',
+        '',
+        '- **`.env`**: sie verlässt diesen Rechner nie und steht in keinem Push. Trage nichts hinein,',
+        '  was die App zum Laufen braucht; dafür gibt es die Umgebungsvariablen in Arkven.',
+        '- **`arkven/nachweis.md`**: ein gerechneter Bericht, keine Quelle. Er kommt beim Holen herunter',
+        '  und geht nie zurück. Ihn zu bearbeiten ändert nichts und täuscht einen Stand vor.',
+        '- **`arkven.spec.json`**: der Prüf-Vertrag. Arkven schreibt ihn fort. Wer einen Bereich baut,',
+        '  ohne ihn dort zu nennen, bekommt für ihn **keine** Prüfung: die Fläche geht ungeprüft live.',
+        '',
+        '### Zwei Fallstricke, die still bleiben',
+        '',
+        '1. **Eine Wahrheit, ein Pfad.** Lege keinen zweiten Speicher für dieselbe Sache an und keinen',
+        '   zweiten Weg, dieselbe Frage zu beantworten. Zwei Quellen laufen auseinander, und niemand',
+        '   merkt es, bis die Antworten sich widersprechen.',
+        '2. **Kein Zustand, der wie Erfolg aussieht.** Kein leerer `catch`, kein Vorgabewert für etwas,',
+        '   das nicht gemessen werden konnte. Was sich nicht messen lässt, wird gemeldet, nicht geraten.',
+        '',
+        MARKE_ENDE,
+    ].join('\n');
+}
+export function agentsNachher(vorher, lage) {
+    const block = agentsBlock(lage);
+    if (vorher === undefined) {
+        return ['# Hinweise für Agenten', '', block, ''].join('\n');
+    }
+    const start = vorher.includes(MARKE_START) ? vorher.indexOf(MARKE_START) : vorher.indexOf(MARKE_START_ALT);
+    const ende = vorher.indexOf(MARKE_ENDE);
+    if (start >= 0 && ende > start) {
+        const neu = vorher.slice(0, start) + block + vorher.slice(ende + MARKE_ENDE.length);
+        return neu === vorher ? undefined : neu;
+    }
+    const basis = vorher.endsWith('\n') || vorher === '' ? vorher : `${vorher}\n`;
+    return `${basis}\n${block}\n`;
+}
+//# sourceMappingURL=agents.js.map

package/dist/agents.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agents.js","sourceRoot":"","sources":["../src/agents.ts"],"names":[],"mappings":"AACA,MAAM,CAAC,MAAM,WAAW,GAAG,sEAAsE,CAAA;AAEjG,MAAM,CAAC,MAAM,eAAe,GAAG,sEAAsE,CAAA;AACrG,MAAM,CAAC,MAAM,UAAU,GAAG,sBAAsB,CAAA;AAWhD,SAAS,eAAe,CAAC,IAAgB;IACvC,MAAM,MAAM,GAAa,EAAE,CAAA;IAC3B,MAAM,CAAC,IAAI,CACT,IAAI,CAAC,aAAa;QAChB,CAAC,CAAC,wJAAwJ;QAC1J,CAAC,CAAC,4IAA4I,CACjJ,CAAA;IACD,MAAM,CAAC,IAAI,CACT,IAAI,CAAC,kBAAkB;QACrB,CAAC,CAAC,+FAA+F;QACjG,CAAC,CAAC,8FAA8F,CACnG,CAAA;IACD,MAAM,CAAC,IAAI,CACT,IAAI,CAAC,aAAa;QAChB,CAAC,CAAC,8JAA8J;QAChK,CAAC,CAAC,wGAAwG,CAC7G,CAAA;IACD,OAAO,MAAM,CAAA;AACf,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,IAAgB;IAC1C,OAAO;QACL,WAAW;QACX,EAAE;QACF,+BAA+B;QAC/B,EAAE;QACF,iGAAiG;QACjG,mFAAmF;QACnF,EAAE;QACF,0CAA0C;QAC1C,EAAE;QACF,GAAG,eAAe,CAAC,IAAI,CAAC;QACxB,EAAE;QACF,iBAAiB;QACjB,EAAE;QACF,SAAS;QACT,gGAAgG;QAChG,gFAAgF;QAChF,2FAA2F;QAC3F,gFAAgF;QAChF,KAAK;QACL,EAAE;QACF,6FAA6F;QAC7F,4EAA4E;QAC5E,EAAE;QACF,kCAAkC;QAClC,EAAE;QACF,8FAA8F;QAC9F,mFAAmF;QACnF,iGAAiG;QACjG,qFAAqF;QACrF,+FAA+F;QAC/F,+FAA+F;QAC/F,EAAE;QACF,yCAAyC;QACzC,EAAE;QACF,+FAA+F;QAC/F,6FAA6F;QAC7F,oDAAoD;QACpD,gGAAgG;QAChG,iGAAiG;QACjG,EAAE;QACF,UAAU;KACX,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;AACd,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,MAA0B,EAAE,IAAgB;IACxE,MAAM,KAAK,GAAG,WAAW,CAAC,IAAI,CAAC,CAAA;IAE/B,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QACzB,OAAO,CAAC,wBAAwB,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IAC7D,CAAC;IAED,MAAM,KAAK,GAAG,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,eAAe,CAAC,CAAA;IAC1G,MAAM,IAAI,GAAG,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,CAAA;IAEvC,IAAI,KAAK,IAAI,CAAC,IAAI,IAAI,GAAG,KAAK,EAAE,CAAC;QAC/B,MAAM,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,GAAG,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,GAAG,UAAU,CAAC,MAAM,CAAC,CAAA;QACnF,OAAO,GAAG,KAAK,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,CAAA;IACzC,CAAC;IAED,MAAM,KAAK,GAAG,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,MAAM,KAAK,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI,CAAA;IAC7E,OAAO,GAAG,KAAK,KAAK,KAAK,IAAI,CAAA;AAC/B,CAAC"}

package/dist/auftrag.d.ts

@@ -0,0 +1,3 @@
+import type { Ergebnis } from './befund.js';
+export declare function baueAuftrag(e: Ergebnis): string;
+//# sourceMappingURL=auftrag.d.ts.map

package/dist/auftrag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auftrag.d.ts","sourceRoot":"","sources":["../src/auftrag.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAE3C,wBAAgB,WAAW,CAAC,CAAC,EAAE,QAAQ,GAAG,MAAM,CA+C/C"}

package/dist/auftrag.js

@@ -0,0 +1,45 @@
+import { fuerAgenten, fuerAgentenZusaetzlich } from './befund.js';
+export function baueAuftrag(e) {
+    const zuTun = fuerAgenten(e.befunde);
+    const kuer = fuerAgentenZusaetzlich(e.befunde);
+    if (zuTun.length === 0 && kuer.length === 0)
+        return '';
+    const punkte = zuTun
+        .map((b, i) => {
+        const zeilen = [`${i + 1}. [${b.regel}]${b.ort ? ` (${b.ort})` : ''}`, `   Was gilt: ${b.titel}`, `   Ziel: ${b.ausweg}`];
+        return zeilen.join('\n');
+    })
+        .join('\n\n');
+    const kuerZeilen = kuer.map((b, i) => [`${i + 1}. [${b.regel}]${b.ort ? ` (${b.ort})` : ''}`, `   Was gilt: ${b.titel}`, `   Ziel: ${b.ausweg}`].join('\n'));
+    const kuerText = kuer.length
+        ? ['', '', `Außerdem ${kuer.length} Punkt(e), die NICHTS aufhalten und die App trotzdem besser machen:`, '', kuerZeilen.join('\n\n'), '', 'Diese zuletzt, nach den Punkten oben.'].join('\n')
+        : '';
+    if (zuTun.length === 0) {
+        return `Dieses Projekt läuft auf Arkven, und der Container-Vertrag hält.${kuerText}
+
+Bitte arbeite die Punkte im Projektverzeichnis ab. Regeln für diese Arbeit:
+
+- Ändere so wenig wie nötig. Kein Umbau, der über die genannten Punkte hinausgeht.
+- Erhalte das Verhalten der Anwendung.
+- Committe nichts und pushe nichts. Die Änderungen bleiben als Arbeitsstand stehen.
+`;
+    }
+    return `Dieses Projekt soll auf Arkven laufen. Arkven baut jede App in einen Container, der
+\`src/index.ts\` mit tsx startet, den Port über PORT und die Datenbank über DATABASE_URL
+hereingibt, und nur die \`dependencies\` der Wurzel-package.json installiert.
+
+Gegen diesen Vertrag halten ${zuTun.length} Punkt(e) nicht:
+
+${punkte}${kuerText}
+
+Bitte behebe sie im Projektverzeichnis. Regeln für diese Arbeit:
+
+- Ändere so wenig wie nötig. Kein Umbau, der über die genannten Punkte hinausgeht.
+- Erhalte das Verhalten der Anwendung. Wo eine Umgebungsvariable neu gelesen wird, bleibt der
+  bisherige Wert der Rückfall für lokale Läufe.
+- Committe nichts und pushe nichts. Die Änderungen bleiben als Arbeitsstand stehen.
+- Wenn ein Punkt eine Entscheidung verlangt, die nur ein Mensch treffen kann, lass ihn liegen und
+  sage am Ende, welcher und warum.
+- Behaupte am Ende NICHT, alles sei behoben. Das misst \`arkven check\` gleich selbst.`;
+}
+//# sourceMappingURL=auftrag.js.map

package/dist/auftrag.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auftrag.js","sourceRoot":"","sources":["../src/auftrag.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAA;AAGjE,MAAM,UAAU,WAAW,CAAC,CAAW;IACrC,MAAM,KAAK,GAAG,WAAW,CAAC,CAAC,CAAC,OAAO,CAAC,CAAA;IACpC,MAAM,IAAI,GAAG,sBAAsB,CAAC,CAAC,CAAC,OAAO,CAAC,CAAA;IAC9C,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAA;IAEtD,MAAM,MAAM,GAAG,KAAK;SACjB,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;QACZ,MAAM,MAAM,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,gBAAgB,CAAC,CAAC,KAAK,EAAE,EAAE,YAAY,CAAC,CAAC,MAAM,EAAE,CAAC,CAAA;QACzH,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IAC1B,CAAC,CAAC;SACD,IAAI,CAAC,MAAM,CAAC,CAAA;IAEf,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CACnC,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,gBAAgB,CAAC,CAAC,KAAK,EAAE,EAAE,YAAY,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CACtH,CAAA;IACD,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM;QAC1B,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,YAAY,IAAI,CAAC,MAAM,qEAAqE,EAAE,EAAE,EAAE,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,uCAAuC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;QAC7L,CAAC,CAAC,EAAE,CAAA;IAEN,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACvB,OAAO,mEAAmE,QAAQ;;;;;;;CAOrF,CAAA;IACC,CAAC;IAED,OAAO;;;;8BAIqB,KAAK,CAAC,MAAM;;EAExC,MAAM,GAAG,QAAQ;;;;;;;;;;uFAUoE,CAAA;AACvF,CAAC"}

package/dist/bauplan.d.ts

@@ -0,0 +1,15 @@
+import type { Befund } from './befund.js';
+import { BAUPLAN_DATEI, AUFTRAG_DATEI } from './geteilt/bauplan/index.js';
+export { BAUPLAN_DATEI, AUFTRAG_DATEI };
+export declare function pruefeBauplan(wurzel: string): Befund[];
+export declare function pruefeBraucht(wurzel: string, braucht: Record<string, boolean>, teile: string[]): Befund[];
+export declare function pruefeMailArten(wurzel: string, arten: readonly string[]): Befund[];
+export declare function pruefeAnker(dateien: ReadonlyArray<{
+    pfad: string;
+    inhalt: string;
+}>, screens: ReadonlyArray<{
+    id: string;
+    name: string;
+    slug?: string;
+}>): Befund[];
+//# sourceMappingURL=bauplan.d.ts.map

package/dist/bauplan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bauplan.d.ts","sourceRoot":"","sources":["../src/bauplan.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACzC,OAAO,EAAkC,aAAa,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAEzG,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,CAAA;AAEvC,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CA6BtD;AA+CD,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAsBzG;AA+BD,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CA0BlF;AAED,wBAAgB,WAAW,CACzB,OAAO,EAAE,aAAa,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,EACxD,OAAO,EAAE,aAAa,CAAC;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GAClE,MAAM,EAAE,CAyDV"}