@cachly-dev/mcp-server 0.10.47 → 0.10.49

package/.github/workflows/eas-build-android.yml

@@ -0,0 +1,58 @@
+name: EAS Build — TCO Android Preview
+
+on:
+  workflow_dispatch:
+    inputs:
+      message:
+        description: 'Build reason'
+        default: 'manual build'
+
+jobs:
+  build:
+    name: Build Android preview APK
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: apps/travel-chaos-organizer/frontend
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Convert SVG icons to PNG (EAS Build requires PNG)
+        run: |
+          sudo apt-get install -y --no-install-recommends librsvg2-bin
+          rsvg-convert -w 1024 -h 1024 assets/icon.svg        -o assets/icon.png
+          rsvg-convert -w 1024 -h 1024 assets/adaptive-icon.svg -o assets/adaptive-icon.png
+          rsvg-convert -w 2048 -h 2048 assets/splash.svg        -o assets/splash.png
+          echo "Icons converted:"
+          ls -lh assets/*.png
+
+      - name: Setup EAS
+        uses: expo/expo-github-action@v8
+        with:
+          eas-version: latest
+          token: ${{ secrets.EXPO_TOKEN }}
+
+      - name: Create .env with production variables
+        run: |
+          echo "EXPO_PUBLIC_API_URL=${{ secrets.EXPO_PUBLIC_API_URL }}" >> .env
+          echo "EXPO_PUBLIC_KEYCLOAK_URL=${{ secrets.EXPO_PUBLIC_KEYCLOAK_URL }}" >> .env
+          echo "EXPO_PUBLIC_KEYCLOAK_REALM=${{ secrets.EXPO_PUBLIC_KEYCLOAK_REALM || 'travel-chaos' }}" >> .env
+          echo "EXPO_PUBLIC_KEYCLOAK_CLIENT_ID=${{ secrets.EXPO_PUBLIC_KEYCLOAK_CLIENT_ID || 'tco-mobile' }}" >> .env
+
+      - name: Build Android (preview — internal distribution)
+        run: |
+          eas build \
+            --profile preview \
+            --platform android \
+            --non-interactive \
+            --no-wait
+        # --no-wait: EAS build runs in the cloud asynchronously.
+        # Download the APK from expo.dev → your project → Builds when done (~10-15 min).

package/.github/workflows/eas-update.yml

@@ -0,0 +1,55 @@
+name: EAS Update — TCO Production
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'apps/travel-chaos-organizer/frontend/**'
+  workflow_dispatch:
+    inputs:
+      message:
+        description: 'Update message'
+        default: 'OTA update'
+
+jobs:
+  update:
+    name: Publish EAS Update to production
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: apps/travel-chaos-organizer/frontend
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: TypeScript typecheck
+        run: npx tsc --noEmit
+
+      - name: Create .env with production variables
+        run: |
+          echo "EXPO_PUBLIC_API_URL=${{ secrets.EXPO_PUBLIC_API_URL }}" >> .env
+          echo "EXPO_PUBLIC_KEYCLOAK_URL=${{ secrets.EXPO_PUBLIC_KEYCLOAK_URL }}" >> .env
+          echo "EXPO_PUBLIC_KEYCLOAK_REALM=${{ secrets.EXPO_PUBLIC_KEYCLOAK_REALM || 'travel-chaos' }}" >> .env
+          echo "EXPO_PUBLIC_KEYCLOAK_CLIENT_ID=${{ secrets.EXPO_PUBLIC_KEYCLOAK_CLIENT_ID || 'tco-mobile' }}" >> .env
+
+      - name: Publish EAS Update
+        env:
+          EXPO_TOKEN: ${{ secrets.EXPO_TOKEN }}
+        run: |
+          MESSAGE="${{ github.event.inputs.message || github.event.head_commit.message }}"
+          MESSAGE="${MESSAGE:0:100}"
+          # Publish to both channels so preview and production builds both get the update
+          npx eas-cli update \
+            --branch production \
+            --message "$MESSAGE" \
+            --non-interactive
+          npx eas-cli update \
+            --branch preview \
+            --message "$MESSAGE" \
+            --non-interactive

package/STRATEGY.md

@@ -0,0 +1,209 @@
+# Cachly vs. Anthropic Memory — Ehrliche Standortbestimmung & 10x/100x-Roadmap
+
+> Stand: 29. Mai 2026 · Verfasst als interne, schonungslose Bestandsaufnahme.
+> Ziel: Wo stehen wir wirklich, was ist der Graben den Anthropic uns gräbt, und
+> was braucht es konkret, damit Cachly für die nächsten Jahre 10–100x besser,
+> stabiler, intelligenter und nutzerfreundlicher dasteht.
+
+---
+
+## 0. TL;DR (für die Eiligen)
+
+- **Die Lücke, die wir füllen wollten, schließt Anthropic gerade selbst** — aber
+  nur für den Solo-Claude-Nutzer. Das Memory Tool, Managed-Agents-Memory,
+  Chat-Memory und "Dreaming" decken den **Single-User-, Single-Vendor-Fall**
+  zunehmend gut ab.
+- **Unser echter, verteidigbarer Graben liegt woanders**: *team-/org-weites,
+  strukturiertes, vendor- und tool-unabhängiges Wissen mit Governance.* Genau das
+  kann Anthropic strukturell **nicht** liefern, ohne ihr eigenes Lock-in-Modell zu
+  untergraben.
+- **Brutale Wahrheit**: Heute gewinnen wir diesen Graben *nicht* überzeugend.
+  Onboarding hat zu viel Reibung, die Recall-Qualität ist nicht nachweisbar besser
+  als "Claude liest seine eigenen Files", und wir hatten zuletzt zu viele Bugs für
+  ein Produkt, das gegen ein First-Party-Feature antritt.
+- **Der Weg zu 10x/100x** ist kein Feature-Wettrennen mit Anthropic. Es ist:
+  (1) **Recall-Qualität messbar überlegen machen**, (2) **Onboarding auf
+  Null-Reibung** bringen, (3) **Team-Wissensgraph zum Moat ausbauen**,
+  (4) **vendor-/tool-agnostisch** bleiben, (5) **Stabilität auf First-Party-Niveau**.
+
+---
+
+## 1. Was Anthropic heute hat (der ehrliche Blick auf den Gegner)
+
+| Feature | Was es ist | Reichweite | Schwäche für uns nutzbar? |
+|---|---|---|---|
+| **Memory Tool** (`memory_20250818`) | Client-seitige Datei-Ops im `/memories`-Verzeichnis, 6 Commands (view/create/str_replace/insert/delete/rename) | Nur Anthropic-API, nur Claude-Modelle | **Ja** — unstrukturiert (flache Files), kein semantisches Retrieval, per-Agent |
+| **Managed Agents Memory** (Public Beta, Apr 2026) | Anthropic-gehostete Files, via API/Console exportierbar | Anthropic-Plattform | **Ja** — kein Team-Sharing-Modell, kein Wissensgraph |
+| **Chat Memory** (März 2026) | Auto-Destillation von Chats ~alle 24h in ein Memory-Profil | Consumer (Free/Pro/Max) | **Ja** — Consumer-only, nicht für Dev-Workflows/CI/Teams |
+| **Dreaming** (Research Preview) | Background-Prozess: Muster aus Sessions extrahieren, Memory kuratieren | Claude-intern | ⚠️ **Gefährlich** — das ist konzeptionell *unser* Crystallize/Belief-Update |
+| **Opus 4.8 Context** | 1M Token default, "infinite conversations" via Summarization, Suche über alte Chats | Claude | ⚠️ Reduziert den *Bedarf* an externem Memory für Solo-User |
+
+### Die unbequeme Erkenntnis
+Anthropics Memory ist **gratis, null Setup, first-party, und wird monatlich besser.**
+Für einen einzelnen Entwickler, der ausschließlich Claude nutzt, ist die Frage
+"Warum Cachly statt dem eingebauten Memory?" heute **nicht trivial zu beantworten.**
+
+---
+
+## 2. Wo Cachly strukturell gewinnen kann (der echte Graben)
+
+Diese vier Punkte kann Anthropic nicht ohne Selbst-Sabotage angreifen:
+
+### 2.1 Vendor- & Tool-Unabhängigkeit
+- Anthropic-Memory lebt **in Anthropics Filesystem, gebunden an Claude über die
+  Anthropic-API.** Wechselst du zu GPT, Gemini, einem lokalen Modell oder nutzt
+  Cursor/Windsurf/Zed parallel — **dein Memory ist weg oder fragmentiert.**
+- Cachly spricht **MCP** → funktioniert mit *jedem* MCP-Client und ist
+  modell-agnostisch. **Dein Org-Wissen überlebt jeden Modellwechsel.**
+- *Das ist die Positionierung, die nie veraltet:* "Switzerland für AI-Memory."
+
+### 2.2 Team-/Org-weites Wissen
+- Anthropic-Memory ist **per-User / per-Agent.** Es gibt kein "Kollege A lernt
+  etwas, Kollege B profitiert beim nächsten `session_start`."
+- `team_learn` + geteilte Brain-Instanz ist **genau das** — und es ist der
+  Use-Case mit dem höchsten ökonomischen Wert (verhindert, dass 10 Entwickler
+  denselben Fehler 10x machen).
+
+### 2.3 Strukturiertes, kuratiertes Wissen statt flacher Files
+- Anthropic = Claude liest linear Textdateien.
+- Cachly = strukturierte Lessons (`topic`, `outcome`, `severity`, `tags`,
+  `depends_on`), Contradiction-Detection, Causal Knowledge Graph (CKG),
+  Belief-Update-Engine (BUE). **ABER:** dieser Vorteil ist heute *behauptet, nicht
+  bewiesen.* Siehe §3.
+
+### 2.4 Governance, Compliance, Self-Hosting
+- Self-hosted Valkey, BYOK, Audit-Trails, DSGVO-Löschung, SOC-2-Pfad.
+- Enterprises **dürfen** ihr Wissen oft nicht in Anthropics Managed Memory legen.
+  Das ist ein Verkaufsargument, das mit der Zeit *stärker* wird, nicht schwächer.
+
+---
+
+## 3. Wo wir heute ehrlich schwach sind
+
+Kein Schönreden:
+
+1. **Recall-Qualität ist nicht gemessen.** Wir behaupten "strukturiert > flache
+   Files", haben aber **kein Benchmark**, das zeigt: Cachly-Recall führt zu
+   weniger Wiederholungsfehlern / besseren Antworten als das eingebaute Memory.
+   *Ohne diesen Beweis ist unser Hauptargument Marketing.*
+2. **Onboarding-Reibung.** Anthropic: 0 Setup. Cachly: Instanz provisionieren,
+   Device-Flow, MCP-Config, JWT-Persistenz, Instance-ID. Jede dieser Stufen ist
+   ein Drop-off-Punkt — und mehrere waren zuletzt **kaputt** (JWT nur im RAM,
+   Redis NOAUTH, Provisioning-Timeouts).
+3. **Stabilität.** Wir haben in den letzten Tagen viele kritische Bugs gefunden und
+   gefixt (Telemetrie-Zähler bei 0, NOAUTH, PKCE komplett kaputt, doppelte Drip-
+   Mails, Admin-Bypass). Ein Produkt, das gegen ein First-Party-Feature antritt,
+   **darf solche Bugs nicht haben.** Vertrauen ist hier asymmetrisch.
+4. **Wertnachweis fehlt dem User.** Der Nutzer sieht nicht, *dass* Cachly ihm
+   gerade einen Fehler erspart hat. Anthropics Memory ist unsichtbar-bequem;
+   unseres ist sichtbar-umständlich. Das muss sich umkehren.
+5. **"Dreaming" ist eine direkte Bedrohung** für unser Crystallize/BUE-
+   Alleinstellungsmerkmal. Wenn das Modell selbst Muster extrahiert, müssen wir
+   beim *Team-übergreifenden* und *strukturierten* Teil uneinholbar sein.
+
+---
+
+## 4. Die 10x/100x-Roadmap (konkret, priorisiert)
+
+> Leitsatz: **Wir gewinnen nicht, indem wir Anthropics Memory kopieren. Wir
+> gewinnen, indem wir das werden, was Anthropic strukturell nicht sein darf:
+> der neutrale, team-weite, beweisbar-bessere Wissens-Layer über allen Modellen.**
+
+### Phase 1 — Stabilität & Null-Reibung (die Eintrittskarte) · *0–3 Monate*
+Ohne das ist alles andere wertlos.
+
+- **[10x Stabilität]** Vollständige Test-Suite für die Brain-Tools (Recall, Learn,
+  Dedup, Contradiction). Heute faktisch ungetestet. Ziel: jede Tool-Antwort hat
+  einen Vertragstest.
+- **[10x Onboarding]** "Ein-Befehl-Setup": `npx @cachly-dev/init` → Auto-Provision,
+  Device-Flow, MCP-Config-Write, erster `brain_from_git`-Seed, alles in <60s,
+  idempotent, mit klarem Fortschritt. Jeder bisherige Drop-off-Punkt eliminiert.
+- **[Reibung]** Graceful Degradation: Wenn Redis/Netz weg ist, darf das Tool
+  **nie** den ganzen Agent-Call blockieren. Timeouts + Circuit-Breaker überall.
+- **[Vertrauen]** Self-Healing-Auth: JWT/Instance-ID persistent, automatische
+  Re-Provisionierung bei verlorenem State, kein "0 Recalls weil RAM-only" mehr.
+
+### Phase 2 — Beweisbar bessere Recall-Qualität (der Moat-Beweis) · *3–9 Monate*
+Das ist der Punkt, an dem wir *verdienen*, gegen First-Party anzutreten.
+
+- **[100x Intelligenz]** Echtes hybrides Retrieval: semantische Embeddings +
+  Reranking + CKG-Traversierung, nicht Keyword-Match. Messbar gegen das
+  eingebaute Memory.
+- **[Beweis]** **Cachly-Bench**: ein offener Benchmark, der zeigt, dass ein Agent
+  *mit* Cachly weniger Wiederholungsfehler macht / schneller zur Lösung kommt als
+  mit Claude-Memory allein. Das ist unsere wichtigste Marketing- *und* Produkt-
+  Investition. Ohne Zahl keine Story.
+- **[Intelligenz]** Contradiction-Resolution, die *wirklich* funktioniert: wenn
+  zwei Lessons sich widersprechen, automatisch via MADC/Voting auflösen und das
+  Ergebnis persistent machen (heute teilweise berechnet, aber nicht gespeichert).
+- **[Wertsichtbarkeit]** "Brain saved you here"-Signal: wenn ein Recall einen
+  bekannten Fehler verhindert, sichtbar machen (im Tool-Output + Dashboard-Metrik).
+
+### Phase 3 — Team-Wissensgraph als uneinholbarer Moat · *9–18 Monate*
+Hier ist Anthropic strukturell raus.
+
+- **[100x Team]** Org-weiter Wissensgraph: Lessons, Personen, Dateien, Services als
+  Knoten; Recall berücksichtigt *wer* was gelernt hat und *wo* es relevant ist.
+- **[Virality]** Jeder gelöste Fehler eines Entwicklers wird automatisch zur
+  Org-Lesson — mit Attribution. `team_learn` als Default, nicht als Opt-in.
+- **[Governance]** Rollen, Sichtbarkeits-Scopes, Audit-Trails, "Wissens-Reviews"
+  (ein Senior bestätigt eine Lesson → höheres Vertrauen im Recall-Ranking).
+- **[Enterprise]** Self-Hosted-Tier mit SOC-2/ISO, BYOK by default, Daten bleiben
+  im Kunden-VPC. Das ist der Umsatz, den Anthropic-Memory nicht abgreifen kann.
+
+### Phase 4 — Der neutrale Layer über allen Modellen · *18+ Monate*
+- **[100x Reichweite]** First-class-Support für jeden großen MCP-Client und jedes
+  Modell. Cachly = "bring your own model, keep your brain."
+- **[Ökosystem]** Öffentliche/teilbare Brains (kuratierte Domänen-Wissensbasen:
+  "React-Best-Practices-Brain", "Kubernetes-Incident-Brain"), als Marktplatz.
+- **[Moat-Vertiefung]** Je mehr Org-Wissen akkumuliert, desto höher die
+  Wechselkosten *weg* von Cachly — aber **null** Lock-in beim *Modell*. Das ist
+  die einzige gesunde Form von Lock-in.
+
+---
+
+## 5. Was wir explizit NICHT tun sollten
+
+- **Nicht** versuchen, Anthropics Single-User-Memory zu schlagen. Das verlieren wir.
+  Unser Nutzer ist das **Team** und die **Org**, nicht der Solo-Hobbyist.
+- **Nicht** Feature-für-Feature mit "Dreaming" konkurrieren. Stattdessen den
+  *strukturierten, geteilten, beweisbar-besseren* Teil besitzen.
+- **Nicht** weiter Features stapeln (wir haben ~89 Tools), solange Recall-Qualität
+  und Stabilität nicht bewiesen sind. **Tiefe vor Breite.**
+- **Nicht** vendor-Lock-in beim Modell aufbauen — das ist unser einziger
+  glaubwürdiger Vorteil gegenüber First-Party.
+
+---
+
+## 6. Die drei Metriken, die alles entscheiden
+
+Wenn wir nur drei Zahlen tracken dürften:
+
+1. **Time-to-first-recall** (Onboarding-Reibung): vom `npx`-Befehl bis zum ersten
+   erfolgreichen, wertvollen Recall. Ziel: <2 Minuten.
+2. **Recall-Lift** (Moat-Beweis): % weniger Wiederholungsfehler / schnellere
+   Lösung *mit* Cachly vs. ohne, gemessen über Cachly-Bench. Ziel: messbar >0,
+   dann skalieren.
+3. **Team-Knowledge-Reuse** (Virality/Moat): wie oft wird die Lesson eines
+   Entwicklers von *einem anderen* erfolgreich recallt. Das ist der Wert, den nur
+   wir liefern.
+
+---
+
+## 7. Fazit (schonungslos)
+
+Anthropic hat die **Single-User-Memory-Lücke** weitgehend geschlossen. Hätten wir
+nur darauf gewettet, wären wir in Schwierigkeiten.
+
+Aber die **eigentlich wertvolle Lücke** — *team-weites, strukturiertes,
+vendor-neutrales, governance-fähiges Wissen mit beweisbarem Recall-Vorteil* — ist
+**offen, und Anthropic kann sie aus strukturellen Gründen nicht schließen.**
+
+Heute besetzen wir diese Lücke **noch nicht überzeugend**: zu viel Reibung, zu
+wenig Beweis, zu viele Bugs. Der Weg zu 10x/100x ist deshalb unspektakulär und
+unerbittlich:
+
+> **Erst stabil & reibungslos. Dann beweisbar schlauer. Dann team-weit
+> uneinholbar. Immer modell-neutral.**
+
+In dieser Reihenfolge. Nicht andersrum.

package/apps/travel-chaos-organizer/.env.example

@@ -0,0 +1,49 @@
+# Travel Chaos Organizer — Environment Variables
+# Copy to .env and fill in your values
+
+# App
+DEBUG=false
+UPLOAD_DIR=/data/uploads
+
+# Database (overridden by docker-compose for containerized runs)
+DATABASE_URL=postgresql+asyncpg://tco:tco@localhost:5432/tco
+
+# Keycloak
+KEYCLOAK_URL=http://localhost:8080
+KEYCLOAK_REALM=travel-chaos
+KEYCLOAK_CLIENT_ID=tco-backend
+
+# Ollama — point to your self-hosted instance
+OLLAMA_URL=http://your-server:11434
+OLLAMA_MODEL=llama3.2-vision
+OLLAMA_TIMEOUT=120
+
+# Cachly Redis — caches Ollama parse results to avoid duplicate AI calls.
+# docker-compose sets this automatically (local Redis).
+# In production, replace with your Cachly instance URL:
+#   cachly.dev → Instances → Connection String
+# Same document uploaded twice? Instant response from cache, no second AI call.
+CACHLY_REDIS_URL=redis://localhost:6379/0
+# CACHLY_REDIS_URL=redis://:<password>@<host>.cachly.dev:6380/0
+
+# Telegram Notifier (optional) — get token from @BotFather
+# TELEGRAM_BOT_TOKEN=...
+# TCO_TELEGRAM_CHAT_ID=...   # chat or channel ID for TCO events
+
+# Email — Resend (optional, https://resend.com)
+# RESEND_API_KEY=re_...
+# RESEND_FROM=noreply@yourdomain.com
+
+# Admin dashboard (change before going live!)
+ADMIN_USER=admin
+ADMIN_PASSWORD=changeme
+
+# CORS — comma-separated origins, or * for all
+CORS_ORIGINS=*
+
+# Stripe
+# STRIPE_SECRET_KEY=sk_live_...
+# STRIPE_WEBHOOK_SECRET=whsec_...
+# STRIPE_PRO_PRICE_ID=price_...
+STRIPE_SUCCESS_URL=https://YOUR_DOMAIN/upgrade/success
+STRIPE_CANCEL_URL=https://YOUR_DOMAIN/upgrade/cancel