Obsidian-taken converteren tussen formaten

Voordat je iets verandert

1. Maak een back-up van de kluis. Kopieer de map of commit hem naar git. Een script dat 4.000 regels herschrijft moet makkelijk terug te draaien zijn.
2. Werk eerst op een kopie. Draai de conversie op een kopie van de kluis, open die in Obsidian en voer een van je gebruikelijke taakquery's uit. Vergelijk de aantallen met het origineel.
3. Eerst converteren, dan de plugin omzetten. Obsidian Tasks leest één formaat tegelijk. Converteer eerst de regels en wijzig daarna het taakformaat in zijn instellingen, zodat de plugin nooit een half geconverteerde kluis ziet.
4. Controleer wat er over is. Zoek in de kluis naar de oude symbolen (📅, ⏳, ⏫ voor emoji; due::, repeat:: voor Dataview) om regels te vinden die het recept heeft overgeslagen.

Welke conversie heb je nodig

Emoji naar Dataview-velden

Elke emoji en zijn waarde wordt een veld tussen haken. Prioriteitsemoji worden een veld priority met een woord, en de herhalingstekst verhuist naar binnen de haken. Voer de vervangingen in deze volgorde uit: eerst datums en prioriteit, herhaling als laatste, zodat de herhalingstekst eindigt waar de volgende haak begint.

Voor en na

- [ ] Send invoice to Acme ⏫ 🔁 every month ➕ 2026-10-01 ⏳ 2026-11-01 📅 2026-11-03 #finance
- [x] Book flights 📅 2026-10-25 ✅ 2026-10-20
- [ ] Order parts 🆔 parts1
- [ ] Assemble 🛫 2026-11-10 ⛔ parts1 📅 2026-11-15

- [ ] Send invoice to Acme  [priority:: high]  [repeat:: every month]  [created:: 2026-10-01]  [scheduled:: 2026-11-01]  [due:: 2026-11-03] #finance
- [x] Book flights  [due:: 2026-10-25]  [completion:: 2026-10-20]
- [ ] Order parts  [id:: parts1]
- [ ] Assemble  [start:: 2026-11-10]  [dependsOn:: parts1]  [due:: 2026-11-15]

Zoeken en vervangen, één veld tegelijk

Deze patronen werken in elke editor met regex-zoeken over meerdere bestanden, zoals VS Code, dat de vastgelegde tekst als $1 schrijft. Zet de regex-modus en hoofdlettergevoeligheid aan. In tegenstelling tot het script draaien ze op elke regel, niet alleen op regels met een selectievakje.

Hetzelfde als script

Sla dit op als emoji_to_dataview.py en voer python3 emoji_to_dataview.py Inbox.md Projects/*.md uit. Het raakt alleen regels met een selectievakje aan, schrijft twee spaties voor elk veld zoals Obsidian Tasks doet, en converteert ook de alternatieve symbolen voor deadline en gepland 📆, 🗓 en ⌛.

#!/usr/bin/env python3
"""Rewrite Obsidian Tasks emoji fields to Dataview [key:: value] fields.

Usage: emoji_to_dataview.py NOTE.md [NOTE.md ...]   (rewrites in place; back up first)
Only checkbox lines are touched. Run it on a copy of your vault first.
"""
import os
import re
import sys

DATE = r"(\d{4}-\d{2}-\d{2})"
ID = r"[A-Za-z0-9_-]+"
RULES = [
    (rf"(?:📅|📆|🗓️?)\s*{DATE}", r"[due:: \1]"),
    (rf"(?:⏳|⌛)\s*{DATE}", r"[scheduled:: \1]"),
    (rf"🛫\s*{DATE}", r"[start:: \1]"),
    (rf"➕\s*{DATE}", r"[created:: \1]"),
    (rf"✅\s*{DATE}", r"[completion:: \1]"),
    (rf"❌\s*{DATE}", r"[cancelled:: \1]"),
    (r"🔺️?", "[priority:: highest]"),
    (r"⏫️?", "[priority:: high]"),
    (r"🔼️?", "[priority:: medium]"),
    (r"🔽️?", "[priority:: low]"),
    (r"⏬️?", "[priority:: lowest]"),
    (r"🏁\s*(keep|delete)", r"[onCompletion:: \1]"),
    (rf"🆔\s*({ID})", r"[id:: \1]"),
    (rf"⛔\s*({ID}(?:\s*,\s*{ID})*)", r"[dependsOn:: \1]"),
    # Last, so the rule text ends at the next bracket or the end of the line.
    (r"🔁\s*([A-Za-z0-9, !]*[A-Za-z0-9])(?=\s*(?:\[|\^|$))", r"[repeat:: \1]"),
]
TASK = re.compile(r"^(\s*(?:[-*+]|\d+\.)\s+\[.\]\s)(.*)$")

for path in sys.argv[1:]:
    out = []
    for raw in open(path, encoding="utf-8", newline="").read().split("\n"):
        cr = "\r" if raw.endswith("\r") else ""
        line = raw[: len(raw) - len(cr)]
        m = TASK.match(line)
        if m:
            head, body = m.groups()
            for pattern, repl in RULES:
                body = re.sub(pattern, repl, body)
            body = re.sub(r"\s*(\[(?:due|scheduled|start|created|completion|cancelled|priority|onCompletion|id|dependsOn|repeat):: )", r"  \1", body)
            line = head + body
        out.append(line + cr)
    tmp = path + ".tmp"
    with open(tmp, "w", encoding="utf-8", newline="") as fh:
        fh.write("\n".join(out))
    os.replace(tmp, path)

Dataview-velden naar emoji

De omgekeerde conversie leest zowel [key:: value] als (key:: value) en schrijft de standaardemoji. Velden die ze niet kent, zoals [project:: Website], blijven ongemoeid op de regel staan, en een prioriteit als getal blijft ongemoeid omdat de plugins het oneens zijn over wat de getallen betekenen.

- [ ] Send invoice to Acme  [priority:: high]  [repeat:: every month]  [created:: 2026-10-01]  [scheduled:: 2026-11-01]  [due:: 2026-11-03] #finance
- [x] Book flights  [due:: 2026-10-25]  [completion:: 2026-10-20]
- [ ] Order parts  [id:: parts1]
- [ ] Assemble  [start:: 2026-11-10]  [dependsOn:: parts1]  [due:: 2026-11-15]

- [ ] Send invoice to Acme ⏫ 🔁 every month ➕ 2026-10-01 ⏳ 2026-11-01 📅 2026-11-03 #finance
- [x] Book flights 📅 2026-10-25 ✅ 2026-10-20
- [ ] Order parts 🆔 parts1
- [ ] Assemble 🛫 2026-11-10 ⛔ parts1 📅 2026-11-15

Op de uitvoer van het vorige script gedraaid, geeft het precies de voorbeeldregels hierboven terug. Echte kluizen zijn minder netjes: regels met 📆, 🗓 of ⌛ komen terug als 📅 of ⏳, en een regel met een lege omschrijving krijgt een extra spatie.

Sla dit op als dataview_to_emoji.py en voer het op dezelfde manier uit.

#!/usr/bin/env python3
"""Rewrite Dataview [key:: value] task fields to Obsidian Tasks emoji fields.

Usage: dataview_to_emoji.py NOTE.md [NOTE.md ...]   (rewrites in place; back up first)
Reads [key:: v] and (key:: v). Only checkbox lines are touched.
"""
import os
import re
import sys

DATE = r"(\d{4}-\d{2}-\d{2})"
ID = r"[A-Za-z0-9_-]+"


def field(key, value):
    return rf"[\[(]\s*{key}::\s*{value}\s*[\])]"


RULES = [
    (field("due", DATE), r"📅 \1"),
    (field("scheduled", DATE), r"⏳ \1"),
    (field("start", DATE), r"🛫 \1"),
    (field("created", DATE), r"➕ \1"),
    (field("completion", DATE), r"✅ \1"),
    (field("cancelled", DATE), r"❌ \1"),
    (field("priority", "highest"), "🔺"),
    (field("priority", "high"), "⏫"),
    (field("priority", "medium"), "🔼"),
    (field("priority", "low"), "🔽"),
    (field("priority", "lowest"), "⏬"),
    (field("onCompletion", "(keep|delete)"), r"🏁 \1"),
    (field("id", f"({ID})"), r"🆔 \1"),
    (field("dependsOn", rf"({ID}(?:\s*,\s*{ID})*)"), r"⛔ \1"),
    (field("repeat", r"([A-Za-z0-9, !]*[A-Za-z0-9])"), r"🔁 \1"),
]
TASK = re.compile(r"^(\s*(?:[-*+]|\d+\.)\s+\[.\]\s)(.*)$")

for path in sys.argv[1:]:
    out = []
    for raw in open(path, encoding="utf-8", newline="").read().split("\n"):
        cr = "\r" if raw.endswith("\r") else ""
        line = raw[: len(raw) - len(cr)]
        m = TASK.match(line)
        if m:
            head, body = m.groups()
            for pattern, repl in RULES:
                body = re.sub(pattern, repl, body, flags=re.I if "priority" in pattern else 0)
            line = head + re.sub(r"[ \t]{2,}", " ", body).rstrip()
        out.append(line + cr)
    tmp = path + ".tmp"
    with open(tmp, "w", encoding="utf-8", newline="") as fh:
        fh.write("\n".join(out))
    os.replace(tmp, path)

Wat de conversie niet afhandelt

• Een regel met tekst tussen twee velden. Obsidian Tasks leest vanaf het eind van de regel, dus die velden had hij al niet gelezen.
• Een blokverwijzing zoals ^abc123 aan het eind van de regel. De scripts laten die staan waar hij staat, en daar verwacht Obsidian hem.
• Syntax die alleen Task Genius kent: tijden na datums, prioriteiten als [#A], project- en contextvelden, iCalendar-herhalingsregels. Laat die regels met rust of converteer ze met de hand.
• Herhalingsregels die het ene formaat anders schrijft. Controleer na de overstap een paar terugkerende taken, vooral die met when done.
• Terugkerende taken die al voltooide kopieën in het bestand hebben. De kopieën zijn gewone voltooide taken en worden zoals elke andere regel geconverteerd.
• Regels binnen codeblokken. De scripts werken regel voor regel en kennen geen omheiningen, dus converteer notities die voorbeelden citeren met de hand.
• Een niet-herkend veld aan het eind van de regel, zoals [custom:: x]. Obsidian Tasks leest vanaf het eind, dus stopt daar en negeert de geconverteerde velden ervoor.
• Een 🔁-regel gevolgd door een #tag. De herhaling blijft ongeconverteerd, dus zet de tag ervoor of converteer die regel met de hand.
• Taken in citaten of callouts (regels die beginnen met > - [ ]). De scripts slaan ze over.
• Een tijd na een datum, zoals 14:30. Die blijft buiten het geconverteerde veld. Obsidian Tasks heeft geen tijdveld, dus alleen Task Genius leest hem.

Taakregels naar taakbestanden

Een taakbestand is een notitie met de velden van de taak in YAML-frontmatter, het formaat dat TaskNotes gebruikt. Niet elk regelveld heeft daar een plek. Zo worden de velden op TaskNotes-eigenschappen afgebeeld.

Waar elk veld heen gaat

due: 2026-11-03

scheduled: 2026-11-01

start: 2026-11-10

dateCreated: 2026-10-01T08:00:00Z

completedDate: 2026-10-20

priority: high

recurrence: "DTSTART:20261103;FREQ=MONTHLY"

tags:
  - finance

onCompletion: delete

id: parts1

blockedBy:
  - uid: "Tasks/Order parts.md"
    reltype: FINISHTOSTART

Een regel tegelijk met TaskNotes

TaskNotes heeft een opdracht Convert to TaskNote en een converteerknop naast selectievakjes die je in de functie-instellingen kunt aanzetten. Beide maken van de regel een nieuw taakbestand en vervangen de regel door een link ernaartoe. Prima voor een paar taken, traag voor een hele kluis.

Veel tegelijk met de TaskForge-opdrachtregel

TaskForge is een aparte app, en de opdrachtregeltool (ook de motor achter de MCP-server) converteert taken tussen regel en bestand, in beide richtingen, enkel of in bulk. Hij heeft een kluis nodig die is ingesteld voor taakbestanden, omdat hij moet weten hoe hij ze herkent. Bekijk eerst een voorbeeld. Een bulkcommit moet het aantal taken herhalen dat het voorbeeld vond, zodat een te brede query niet meer kan converteren dan je bedoelde.

taskforge convert --query 'tag:home' --to tasknotes --folder Tasks --dry-run
taskforge convert --query 'tag:home' --to tasknotes --folder Tasks --acknowledge-count 2

Een echte run

- [ ] Send invoice to Acme ⏫ 🔁 every month 📅 2026-11-03 #finance

---
title: Send invoice to Acme
status: open
priority: high
tags:
  - finance
  - task
recurrence: "DTSTART:20261103;FREQ=MONTHLY"
due: 2026-11-03
---

De prioriteit ⏫ werd high en every month werd een iCalendar-regel verankerd op de deadline. In een tweede run bleven een startdatum, een actie bij voltooiing en een taak-ID bewaard als gewone frontmattersleutels (start, onCompletion, id) in plaats van te vervallen. De opdracht weigert elke taak die hij niet in zijn geheel kan converteren. Als je een bestand terug naar een regel converteert, krijgt de regel de identificerende tag van het bestand, task.

Om de andere kant op te gaan, noem je een doelnotitie, en bekijk je eerst een voorbeeld:

taskforge convert --query 'tag:home' --to inline --folder Inbox.md --dry-run

Veelgestelde vragen