Add blog post: Thinking in Notes

.github/workflows/deploy.yml

@@ -5,13 +5,20 @@ on:
     branches:
       - main
   pull_request:
+    types:
+      - opened
+      - synchronize
+      - reopened
+      - closed
 
 jobs:
   deploy:
     runs-on: ubuntu-latest
     permissions:
       contents: read
       deployments: write
+      issues: write
+      pull-requests: write
 
     steps:
       - uses: actions/checkout@v4
@@ -25,35 +32,148 @@ jobs:
       - name: Install dependencies
         run: npm ci
 
-      - name: Build
+      - name: Build Next.js
         run: npm run build
         env:
           NODE_ENV: production
 
-      - name: Deploy to Cloudflare (Preview for PR / Production for main)
-        uses: cloudflare/wrangler-action@v3
-        with:
-          apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}
-          accountId: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
-          command: |
-            if [ "${{ github.event_name }}" = "pull_request" ]; then
-              # Deploy to preview with unique name based on PR number
-              opennextjs-cloudflare build
-              wrangler deploy --env preview --name sparkmemos-pr-${{ github.event.pull_request.number }}
-            else
-              # Deploy to production
-              opennextjs-cloudflare deploy
-            fi
+      - name: Build OpenNext
+        run: npx opennextjs-cloudflare build
+
+      - name: Install Wrangler
+        run: npm install -g wrangler
+
+      # Deploy to main domain (main branch only)
+      - name: Deploy to Cloudflare (Main)
+        if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+        run: wrangler deploy
+        env:
+          CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
+          CLOUDFLARE_ACCOUNT_ID: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
+
+      # Deploy to preview environment (PR only)
+      - name: Deploy to Cloudflare (Preview)
+        if: github.event_name == 'pull_request'
+        run: |
+          wrangler deploy --env pr-${{ github.event.pull_request.number }} --legacy-env
+        env:
+          CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
+          CLOUDFLARE_ACCOUNT_ID: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
+
+      # Get actual domain from Cloudflare API
+      - name: Get deployment URL
+        if: github.event_name == 'pull_request'
+        id: get-url
+        run: |
+          PR_NUM=${{ github.event.pull_request.number }}
+          ACCOUNT_ID=${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
+          WORKER_NAME="sparkmemos"
+
+          SUBDOMAIN_RESPONSE=$(curl -s -X GET \
+            "https://api.cloudflare.com/client/v4/accounts/${ACCOUNT_ID}/workers/subdomain" \
+            -H "Authorization: Bearer ${{ secrets.CLOUDFLARE_API_TOKEN }}" \
+            -H "Content-Type: application/json")
+
+          ACCOUNT_SUBDOMAIN=$(echo $SUBDOMAIN_RESPONSE | jq -r '.result.subdomain // empty')
+
+          if [ -z "$ACCOUNT_SUBDOMAIN" ]; then
+            ACCOUNT_SUBDOMAIN=$ACCOUNT_ID
+          fi
+
+          PREVIEW_URL="https://${WORKER_NAME}-pr-${PR_NUM}.${ACCOUNT_SUBDOMAIN}.workers.dev"
+
+          echo "Preview URL: $PREVIEW_URL"
+          echo "preview_url=${PREVIEW_URL}" >> $GITHUB_OUTPUT
+        env:
+          CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
+          CLOUDFLARE_ACCOUNT_ID: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
 
+      # Comment preview link on PR
       - name: Deploy status comment
         if: github.event_name == 'pull_request'
         uses: actions/github-script@v7
         with:
           script: |
-            const previewUrl = `https://sparkmemos-pr-${{ github.event.pull_request.number }}.workers.dev`;
+            const previewUrl = process.env.PREVIEW_URL;
+            const prNumber = context.payload.pull_request.number;
+            const owner = context.repo.owner;
+            const repo = context.repo.repo;
+
+            const { data: comments } = await github.rest.issues.listComments({
+              owner,
+              repo,
+              issue_number: prNumber
+            });
+
+            const existingComment = comments.find(comment => 
+              comment.body.includes('🚀 Preview deployed:')
+            );
+
+            const commentBody = `🚀 Preview deployed: ${previewUrl}`;
+
+            if (existingComment) {
+              await github.rest.issues.updateComment({
+                owner,
+                repo,
+                comment_id: existingComment.id,
+                body: commentBody
+              });
+            } else {
+              await github.rest.issues.createComment({
+                owner,
+                repo,
+                issue_number: prNumber,
+                body: commentBody
+              });
+            }
+        env:
+          PREVIEW_URL: ${{ steps.get-url.outputs.preview_url }}
+
+  cleanup:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      deployments: write
+      issues: write
+      pull-requests: write
+
+    if: github.event_name == 'pull_request' && github.event.action == 'closed'
+
+    steps:
+      - name: Install Wrangler
+        run: npm install -g wrangler
+
+      - name: Cleanup preview environment
+        run: |
+          PR_NUM=${{ github.event.pull_request.number }}
+          ACCOUNT_ID=${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
+          WORKER_NAME="sparkmemos"
+
+          echo "Cleaning up preview environment for PR #${PR_NUM}"
+
+          RESPONSE=$(curl -s -X DELETE \
+            "https://api.cloudflare.com/client/v4/accounts/${ACCOUNT_ID}/workers/scripts/${WORKER_NAME}/environments/pr-${PR_NUM}" \
+            -H "Authorization: Bearer ${{ secrets.CLOUDFLARE_API_TOKEN }}" \
+            -H "Content-Type: application/json")
+
+          echo "API Cleanup response: $RESPONSE"
+
+          echo "Cleanup completed for PR #${PR_NUM}"
+        env:
+          CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
+          CLOUDFLARE_ACCOUNT_ID: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
+
+      - name: Add cleanup comment
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const prNumber = context.payload.pull_request.number;
+            const owner = context.repo.owner;
+            const repo = context.repo.repo;
+
             await github.rest.issues.createComment({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              issue_number: context.payload.pull_request.number,
-              body: `🚀 Preview deployed: ${previewUrl}`
+              owner,
+              repo,
+              issue_number: prNumber,
+              body: `🧹 Preview environment cleaned up (PR #${prNumber} closed/merged)`
             });

README.md

@@ -34,3 +34,4 @@ You can check out [the Next.js GitHub repository](https://github.com/vercel/next
 The easiest way to deploy your Next.js app is to use the [Vercel Platform](https://vercel.com/new?utm_medium=default-template&filter=next.js&utm_source=create-next-app&utm_campaign=create-next-app-readme) from the creators of Next.js.
 
 Check out our [Next.js deployment documentation](https://nextjs.org/docs/deployment) for more details.
+# Test

blog/posts/2026-03-13-thinking-in-notes/de.md

@@ -0,0 +1,73 @@
+---
+title: In Notizen Denken
+slug: thinking-in-notes
+lang: de
+date: 2026-03-13 00:00:00
+categories:
+  - usage
+tags:
+  - Usage
+description: Notizen sind nicht nur Speicher—sie sind ein Werkzeug zum Denken. Erfahre, wie das Festhalten von Ideen die Art verändert, wie dein Gehirn arbeitet.
+keywords:
+  - Notizen
+  - Denkwerkzeug
+  - kognitive Entlastung
+  - kreatives Denken
+  - Ideenentwicklung
+  - Spark Memos
+  - geistige Klarheit
+---
+
+## Warum Schreiben Verändert, Wie Du Denkst
+
+Hier ist etwas Seltsames: Manchmal verstehst du eine Idee erst wirklich, wenn du versuchst, sie aufzuschreiben.
+
+Es geht nicht um die Notizen selbst. Es geht darum, was in deinem Kopf passiert, wenn du einen vagen Gedanken in Worte auf einem Bildschirm übersetzt. Diese Übersetzung? Das ist, wo die Magie passiert.
+
+### Die Lücke Zwischen Denken und Wissen
+
+Wir glauben gerne, dass unser Gehirn ein Festplattenspeicher ist. Ideen kommen rein, bleiben drin, wir können sie später abrufen. Aber so funktioniert Denken nicht.
+
+Wenn du eine Idee hast, *glaubst* du nur, sie zu verstehen. Der Moment, in dem du sie festzuschreiben versuchst—aufschreiben, jemandem erklären, Entscheidungen darüber treffen—das ist, wenn Lücken auftauchen. Mehrdeutigkeiten, die du nicht bemerkt hast. Verbindungen, die du für offensichtlich hieltest, aber es nicht sind. Logik, die wasserdicht schien, aber bei näherer Betrachtung zusammenbricht.
+
+Deshalb ist Notieren nicht nur Aufzeichnen. Es ist *Offenlegen*.
+
+### Was Passiert, Wenn Du Schreibst
+
+Wenn du etwas aufschreibst, passieren mehrere Dinge:
+
+**Externalisierung.** Einen Gedanken aus dem Kopf zu bewegen, schafft Distanz. Diese Distanz erlaubt es dir, den Gedanken anzuschauen, anstatt ihn nur zu *haben*. Es ist der Unterschied zwischen in einem Labyrinth zu sein und eine Karte davon anzuschauen.
+
+**Klärung.** Vage Ideen zerfallen unter dem Druck der geschriebenen Sprache. "Ich sollte irgendwann an dem Projekt arbeiten" wird zu "Den Projektentwurf bis Freitag fertigstellen"—oder es zeigt, dass du keine Ahnung hast, was "das Projekt" eigentlich bedeutet. Auf jeden Fall hast du etwas gelernt.
+
+**Verbindungen herstellen.** Sobald Ideen außerhalb deines Kopfes existieren, kannst du sie vergleichen. Diese Notiz verbindet sich mit jener. Dieser Gedanke widerspricht etwas, das du letzte Woche geschrieben hast. Diese Muster werden auf eine Weise sichtbar, wie sie es nie sind, wenn alles nur in deinem Gedächtnis lebt.
+
+### Das Problem Damit, Alles im Kopf zu Behalten
+
+Dein Arbeitsgedächtnis kann vielleicht nur vier bis sieben Dinge gleichzeitig halten. Mehr nicht. Jeder Gedanke "Das will ich nicht vergessen" belegt einen dieser Plätze. Du denkst nicht über deine Idee nach—du hältst sie nur fest.
+
+Das nennen Forscher "kognitive Belastung". Wenn dein Gehirn damit beschäftigt ist, sich zu erinnern, hat es weniger Kapazität, wirklich mit Ideen zu arbeiten. Dinge aufzuschreiben befreit mentalen Raum für tieferes Denken.
+
+### Eine Einfache Praxis
+
+Du brauchst kein kompliziertes System. Du brauchst eine Gewohnheit:
+
+1. Wenn etwas wert ist, erinnert zu werden, schreibe es auf. Nicht um es für immer zu speichern—nur um es aus dem Kopf zu bekommen.
+2. Wenn du ein Problem zu lösen hast, schreibe auf, was du bisher weißt. Dann schreibe auf, was du nicht weißt. Die Lücken werden sichtbar.
+3. Wenn eine Idee dich begeistert, schreibe sie so auf, als würdest du sie jemandem erklären, der nicht weiß, was du weißt. Hier wird Klarheit aufgebaut.
+
+Das war's. Drei Praktiken. Das Werkzeug ist weniger wichtig als das Tun.
+
+### Der Spark-Memos-Ansatz
+
+Spark Memos entfernt die Reibung aus diesem Prozess. Keine Ordner zum Erstellen. Keine Tags zum Entscheiden. Keine "wo kommt das hin?"-Lähmung. Einfach öffnen, tippen, fertig.
+
+Denn je einfacher es ist, einen Gedanken zu externalisieren, desto wahrscheinlicher tust du es. Und je mehr du übst, Gedanken zu externalisieren, desto besser wirst du durch Schreiben zu denken.
+
+### Klein Anfangen
+
+Du musst nicht alles erfassen. Beginne mit einer Sache pro Tag—nur ein Gedanke, der es wert ist, festgehalten zu werden. Schreib ihn auf. Beobachte, wie das Aufschreiben verändert, was du darüber denkst.
+
+Mit der Zeit wirst du etwas bemerken: Deine Gedanken werden klarer. Nicht weil du klüger bist, sondern weil du eine Brücke gebaut hast zwischen Ideen haben und sie verstehen.
+
+Das bedeutet wirklich, in Notizen zu denken.

blog/posts/2026-03-13-thinking-in-notes/en.md

@@ -0,0 +1,74 @@
+---
+title: Thinking in Notes
+slug: thinking-in-notes
+lang: en
+date: 2026-03-13 00:00:00
+categories:
+  - usage
+tags:
+  - Usage
+description: Notes aren't just storage—they're a thinking tool. Learn how capturing ideas transforms the way your brain works.
+keywords:
+  - note-taking
+  - thinking tool
+  - brain dump
+  - cognitive offloading
+  - creative thinking
+  - idea development
+  - Spark Memos
+  - mental clarity
+---
+
+## Why Writing Changes How You Think
+
+Here's something weird: sometimes you don't really understand an idea until you try to write it down.
+
+It's not about the notes themselves. It's about what happens in your head when you translate a fuzzy thought into words on a screen. That translation process? That's where the magic happens.
+
+### The Gap Between Thinking and Knowing
+
+We like to think our brains are solid-state storage. Ideas go in, they stay in, we can retrieve them later. But that's not how thinking works.
+
+When you have an idea, you only *think* you understand it. The moment you try to pin it down—write it out, explain it to someone, make decisions about it—that's when gaps appear. Ambiguities you didn't notice. Connections you thought were obvious but aren't. Logic that seemed airtight but falls apart under scrutiny.
+
+This is why note-taking isn't just about recording. It's about *revealing*.
+
+### What Happens When You Write
+
+When you write something down, several things kick in:
+
+**Externalization.** Moving a thought outside your head creates distance. That distance lets you look at the thought instead of just *having* it. It's the difference between being inside a maze and looking at a map of one.
+
+**Clarification.** Vague ideas collapse under the pressure of written language. "I should work on that project sometime" becomes "Finish the project draft by Friday"—or it reveals you have no idea what "that project" actually means. Either way, you've learned something.
+
+**Connection-making.** Once ideas exist outside your head, you can compare them. This note connects to that one. This thought contradicts something you wrote last week. These patterns become visible in a way they never are when everything lives only in your memory.
+
+### The Problem with Keeping It All in Your Head
+
+Your working memory can hold maybe four to seven things at once. That's it. Every "I don't want to forget this" thought is consuming one of those slots. You're not thinking about your idea—you're just holding onto it.
+
+This is what researchers call "cognitive load." When your brain is busy remembering, it has less capacity for actually working with the ideas. Writing things down frees up mental space for deeper thinking.
+
+### A Simple Practice
+
+You don't need a complex system. You need a habit:
+
+1. When something feels worth remembering, write it down. Not to save it forever—just to get it out of your head.
+2. When you have a problem to solve, write what you know so far. Then write what you don't know. The gaps become visible.
+3. When an idea excites you, write it as if you're explaining it to someone who doesn't know what you know. This is where clarity gets built.
+
+That's it. Three practices. The tool matters less than doing it.
+
+### The Spark Memos Angle
+
+Spark Memos removes friction from this process. No folders to create. No tags to decide. No "where does this go?" paralysis. Just open, type, done.
+
+Because the easier it is to externalize a thought, the more likely you are to do it. And the more you practice externalizing thoughts, the better you get at thinking through writing.
+
+### Start Small
+
+You don't need to capture everything. Start with one thing a day—just one thought that's worth holding onto. Write it down. Watch how the act of writing changes what you think about it.
+
+Over time, you'll notice something: your thoughts get clearer. Not because you're smarter, but because you've built a bridge between having ideas and understanding them.
+
+That's what thinking in notes really means.