feat(notes): datoerne følger med, billederne bliver tegnet, og listen kan sorteres

Fire ting, som en rigtig import af tolv hundrede noter fandt på en time.

**Billederne blev vist som ord.** `markdownToHtml` havde ingen regel for
`![](…)` overhovedet, så en note fra Apple Noter viste sin egen billedadresse som
tekst. Filen var hentet, gemt og hæftet på noten; det eneste, der manglede, var
at nogen tegnede den. Kun vores egen adresse bliver til et billede — et
`![](http://…)` fra en indsat tekst ville ellers hente fra en fremmed vært, når
noten åbnes, og en note er det sidste sted, man vil have en sporingspixel. Og
vejen tilbage skulle med: uden `IMG` i inlineToMarkdown ville den første gemning
have taget hvert billede ud af noten igen.

**Titlen blev revet i stykker.** Noter deler en linje op i så mange stumper, den
har brug for — "Aalborg Kommune" står som
`<h1>A</h1><h1>alb</h1><h1>org Kom</h1><h1>mune</h1>`, fordi der er en
attributkørsel bag hver stump — og eksporten læste et linjeskift ved hver af dem.
Noten kom ud som fire overskrifter oven på hinanden, altså ødelagt på den mest
synlige måde der findes: i sin egen titel. Samme rod gav `**M****øde**` for fed
og `*M**øde*` for kursiv, hvor de to stjerner i midten læses som fed. Nu brydes
der kun, når blokken skifter, og et mærke, der lukkes og straks åbnes igen, er
ingenting.

**Datoerne fandtes ikke.** Eksporten læste dem aldrig, og Markdown havde ingen
plads til dem — så en flytning af tolv hundrede noter blev en bunke, der alle var
skrevet samme aften. Rækkefølgen er halvdelen af, hvad et arkiv er. Nu står de i
et YAML-hoved, som Obsidian og Bear allerede skriver, og importen læser det.
`SetNoteTimes` frem for gennem SaveNote: `updated_at` betyder "hvornår skrev
*dette* program noten sidst", og lod man enhver kalder sætte den, ville kolonnen
betyde det, den sidste skriver havde lyst til.

**Og listen kan sorteres** — senest rørt, oprettet, navn. Favoritter står øverst
uanset hvad; det er hele meningen med at gøre en note til favorit.

Eksporten henter nu i klumper. Ét kald pr. note tog halvanden time for tolv
hundrede, ikke fordi Noter er langsom, men fordi hvert kald er en proces, der
skal startes — og det gjorde det umuligt at rette en fejl i oversættelsen og se
resultatet, for hver runde var en frokostpause. Antallet af bilag kom med i
klumpen af samme grund: ni ud af ti kald var en proces startet for at få svaret
nul.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

tools/apple-notes-til-markdown.py

@@ -31,6 +31,9 @@ import sys
 from html.parser import HTMLParser
 
 BLOCK_PREFIX = {"h1": "# ", "h2": "## ", "h3": "### ", "h4": "#### "}
+# Fra lukkemærke tilbage til åbnemærke, når et mærke skal deles over to linjer.
+OPENER = {"**": "**", "*": "*", "</u>": "<u>"}
+MARKS_ONLY = re.compile(r"(?:\*\*|\*|~~|<u>|</u>|\s)*")
 FORBIDDEN = set('/\\:*?"<>|')
 
 
@@ -69,8 +72,26 @@ class NoteParser(HTMLParser):
     # --- linjer ---------------------------------------------------------------
 
     def _flush_line(self):
+        # Et mærke, der står åbent, når linjen slutter, lukkes her og åbnes igen på
+        # den næste.
+        #
+        # Noter skriver <b>Møde forberedelse<br></b>: linjeskiftet ligger *inde i*
+        # det fede. Skrev man linjen ud uden videre, blev de to stjerner, der lukker,
+        # til den næste linjes første tegn — "**Møde forberedelse" og så en linje med
+        # "**" på. Markdown er linjebaseret; et mærke, der skal over et linjeskift,
+        # findes ikke, og skal derfor deles i to.
+        reopen = list(self.marks)
+        for closer in reversed(self.marks):
+            self.line.append(closer)
+
         text = "".join(self.line).rstrip()
-        self.line = []
+
+        # En linje, der kun er mærker, er en tom linje. Det sker for den sidste
+        # stump af et fedt afsnit, hvor der ikke står andet end linjeskiftet.
+        if MARKS_ONLY.fullmatch(text):
+            text = ""
+
+        self.line = [OPENER[c] for c in reopen]
         mono, self.mono = self.mono, False
 
         if mono:
@@ -121,11 +142,42 @@ class NoteParser(HTMLParser):
             self.lines.append("")
         self.mono_lines = []
 
+    def _open(self, opener: str, closer: str):
+        """Åbner et mærke — eller fortryder det, der lige lukkede.
+
+        Noter deler også fremhævet tekst op i kørsler: "Møde" står som
+        <b>M</b><b>øde</b>, fordi der er en attributkørsel bag hver stump. Skrevet
+        ligeud bliver det **M****øde**, som er ét ord i fed sagt på den grimmest
+        mulige måde — og for kursiv bliver det *M**øde*, hvor de to stjerner i
+        midten læses som fed af enhver Markdown-læser. Ordet kom ud forkert.
+
+        Lukkes et mærke og åbnes det samme igen med det samme, er der ikke sket
+        noget imellem. Så tages lukningen tilbage, og de to kørsler er ét mærke.
+        """
+        if self.line and self.line[-1] == closer:
+            self.line.pop()
+        else:
+            self.line.append(opener)
+        self.marks.append(closer)
+
     # --- tags -----------------------------------------------------------------
 
     def handle_starttag(self, tag, attrs):
         if tag in BLOCK_PREFIX:
-            self._flush_line()
+            # En overskrift, der fortsætter den forrige, er den samme linje.
+            #
+            # Noter deler en linje op i så mange stumper, den har brug for — en
+            # overskrift skrevet i ét hug står som
+            # <h1>A</h1><h1>alb</h1><h1>org Kom</h1><h1>mune</h1>, fordi der er en
+            # attributkørsel bag hver stump. Læste man et linjeskift ved hver <h1>,
+            # blev "Aalborg Kommune" til fire overskrifter oven på hinanden, og
+            # noten så ødelagt ud på den mest synlige måde, der findes: i sin egen
+            # titel.
+            #
+            # Der brydes derfor kun, når blokken skifter til en anden slags. Selve
+            # linjeskiftene kommer fra <div> og <br>, som er dem, der betyder det.
+            if self.block != tag:
+                self._flush_line()
             self.block = tag
         elif tag in ("ul", "ol"):
             self._flush_line()
@@ -138,23 +190,24 @@ class NoteParser(HTMLParser):
             # Mærket sættes på linjen og aflæses, når den skrives ud.
             self.mono = True
         elif tag in ("b", "strong"):
-            self.marks.append("**")
-            self.line.append("**")
+            self._open("**", "**")
         elif tag in ("i", "em"):
-            self.marks.append("*")
-            self.line.append("*")
+            self._open("*", "*")
         elif tag == "u":
-            self.marks.append("</u>")
-            self.line.append("<u>")
+            self._open("<u>", "</u>")
         elif tag == "br":
             self._flush_line()
+            self.block = None
         elif tag == "div":
             self._flush_line()
+            self.block = None
 
     def handle_endtag(self, tag):
         if tag in BLOCK_PREFIX:
-            self._flush_line()
-            self.block = None
+            # Ikke her. Lukkes overskriften ved sit eget sluttag, kan den næste
+            # stump af samme linje ikke se, at den hører til — det er <div> og <br>,
+            # der afgør, hvor linjen holder op.
+            pass
         elif tag in ("ul", "ol"):
             self._flush_line()
             if self.list_kind:
@@ -172,6 +225,7 @@ class NoteParser(HTMLParser):
                 self.line.append(self.marks.pop())
         elif tag == "div":
             self._flush_line()
+            self.block = None
 
     def handle_data(self, data):
         self.line.append(data)
@@ -208,6 +262,95 @@ def safe_name(title: str, fallback: str) -> str:
     return name[:80] or fallback
 
 
+# Skilletegn, der ikke står i en note: enhedsadskillere fra ASCII, som ingen
+# skriver med et tastatur.
+FIELD, RECORD = "\u241f", "\u241e"
+
+
+def osascript_file(script: str) -> str:
+    """Som osascript(), men til et manuskript, der er for stort til -e."""
+    import tempfile
+    with tempfile.NamedTemporaryFile("w", suffix=".applescript", delete=False,
+                                     encoding="utf-8") as f:
+        f.write(script)
+        path = f.name
+    try:
+        out = subprocess.run(["osascript", path], capture_output=True, text=True,
+                             timeout=600, check=False)
+        return out.stdout
+    except subprocess.SubprocessError:
+        return ""
+    finally:
+        os.unlink(path)
+
+
+def fetch(ids: list[str]) -> list[dict]:
+    """Navn, krop og datoer for en håndfuld noter i ét kald.
+
+    Ét kald pr. note var det oplagte, og det tog halvanden time for tolv hundrede
+    — ikke fordi Noter er langsom, men fordi hvert kald er en proces, der skal
+    startes. Det gjorde det umuligt at rette en fejl i oversættelsen og se
+    resultatet: hver runde var en frokostpause. Nu hentes de i klumper, og hele
+    eksporten tager minutter.
+
+    Klumper frem for alle på én gang, fordi en enkelt uleselig note ellers ville
+    tage hele kørslen med sig — og fordi svaret skal kunne være i hukommelsen.
+
+    Datoerne læses som tal frem for som tekst. `creation date` giver en dato
+    formateret efter maskinens sprog, og den ville skulle gættes tilbage; year,
+    month og day er de samme tal på enhver maskine.
+    """
+    quoted = ", ".join('"' + i.replace('"', '\\"') + '"' for i in ids)
+    script = f'''
+tell application "Notes"
+	set out to ""
+	repeat with theId in {{{quoted}}}
+		try
+			set n to note id theId
+			set c to creation date of n
+			set m to modification date of n
+			set out to out & (name of n) & "{FIELD}" & ¬
+				((year of c) & "-" & (month of c as integer) & "-" & (day of c) & "T" & ¬
+				 (hours of c) & ":" & (minutes of c) & ":" & (seconds of c)) & "{FIELD}" & ¬
+				((year of m) & "-" & (month of m as integer) & "-" & (day of m) & "T" & ¬
+				 (hours of m) & ":" & (minutes of m) & ":" & (seconds of m)) & "{FIELD}" & ¬
+				(count of attachments of n) & "{FIELD}" & ¬
+				(body of n) & "{RECORD}"
+		on error
+			set out to out & "{FIELD}{FIELD}{FIELD}{FIELD}" & "{RECORD}"
+		end try
+	end repeat
+	return out
+end tell
+'''
+    raw = osascript_file(script)
+    rows = []
+    for chunk in raw.split(RECORD):
+        if not chunk.strip("\n "):
+            continue
+        parts = chunk.split(FIELD)
+        if len(parts) < 5:
+            rows.append({"name": "", "created": "", "modified": "", "files": 0, "body": ""})
+            continue
+        rows.append({
+            "name": parts[0].lstrip("\n"), "created": parts[1], "modified": parts[2],
+            "files": int(parts[3]) if parts[3].strip().isdigit() else 0,
+            "body": parts[4],
+        })
+    return rows
+
+
+def iso(stamp: str) -> str:
+    """"2026-8-17T12:55:14" → "2026-08-17T12:55:14". Nul foran, så det sorterer."""
+    try:
+        date, _, time = stamp.partition("T")
+        y, mo, d = (int(x) for x in date.split("-"))
+        h, mi, se = (int(x) for x in time.split(":"))
+        return f"{y:04d}-{mo:02d}-{d:02d}T{h:02d}:{mi:02d}:{se:02d}"
+    except (ValueError, AttributeError):
+        return ""
+
+
 def main() -> int:
     out_dir = sys.argv[1] if len(sys.argv) > 1 else os.path.expanduser("~/Desktop/apple-noter")
     limit = int(sys.argv[2]) if len(sys.argv) > 2 else 0
@@ -238,16 +381,15 @@ def main() -> int:
     used: dict[str, int] = {}
     attachments_dir = os.path.join(out_dir, "vedhaeftninger")
 
-    for i, note_id in enumerate(ids, start=1):
-        # Navn og krop i ét kald, adskilt af noget, der ikke står i en note.
-        # Hentet hver for sig kunne de nå at komme fra hver sin note.
-        both = osascript(
-            f'tell application "Notes" to tell note id "{note_id}" '
-            f'to return name & "\u241E" & body'
-        )
-        title, _, body = both.partition("\u241E")
-        title = title.strip() or f"uden titel {i}"
-        text = to_markdown(body)
+    CHUNK = 40
+    fetched: list[dict] = []
+    for start in range(0, len(ids), CHUNK):
+        fetched.extend(fetch(ids[start:start + CHUNK]))
+        print(f"  hentet {min(start + CHUNK, len(ids))} / {total}")
+
+    for i, (note_id, row) in enumerate(zip(ids, fetched), start=1):
+        title = row["name"].strip() or f"uden titel {i}"
+        text = to_markdown(row["body"])
 
         # Kroppen begynder med notens egen titel. Skrives der en overskrift
         # ovenover, står titlen to gange i hver eneste note.
@@ -293,18 +435,34 @@ def main() -> int:
         used[name] = used.get(name, 0) + 1
         path = os.path.join(out_dir, name if used[name] == 1 else f"{name} ({used[name]})") + ".md"
 
+        # Datoerne i et hoved, som enhver anden Markdown-læser kender.
+        #
+        # Uden dem er en flytning af tolv hundrede noter en bunke, der alle er
+        # skrevet samme aften: rækkefølgen, som er halvdelen af hvad et arkiv er,
+        # findes ikke længere. Obsidian, Bear og alt andet læser den her blok, og
+        # verdandes egen import gør nu også.
+        created, modified = iso(row["created"]), iso(row["modified"])
+        head = ""
+        if created or modified:
+            head = "---\n"
+            if created:
+                head += f"created: {created}\n"
+            if modified:
+                head += f"modified: {modified}\n"
+            head += "---\n\n"
+
         with open(path, "w", encoding="utf-8") as f:
-            f.write(f"# {title}\n\n{text}\n")
+            f.write(f"{head}# {title}\n\n{text}\n")
 
         # Billeder og bilag. En note fra Noter er ofte fuld af fotografier, og en
         # note, der kommer over som ord alene, er ikke den note.
-        count = osascript(
-            f'tell application "Notes" to return count of attachments of note id "{note_id}"'
-        )
-        if count.isdigit() and int(count) > 0:
+        # Antallet kom med i klumpen. Det var ét kald pr. note, og da kun hver
+        # tiende note har et bilag, var de ni af dem en proces startet for at få
+        # svaret nul.
+        if row["files"] > 0:
             os.makedirs(attachments_dir, exist_ok=True)
             with open(path, "a", encoding="utf-8") as f:
-                for j in range(1, int(count) + 1):
+                for j in range(1, row["files"] + 1):
                     a_name = osascript(
                         f'tell application "Notes" to return name of attachment {j} '
                         f'of note id "{note_id}"'