@remigius42/morg 0.4.0

package/dist/presets/logseq.js

@@ -0,0 +1,298 @@
+import { visit } from "unist-util-visit";
+import { toString } from "orgast-util-to-string";
+/**
+ * Logseq dialect preset: `heading::` properties and outline nesting.
+ */
+export function logseq(options = {}) {
+    const nestUnderHeadings = options.nestUnderHeadings ?? true;
+    return {
+        name: "logseq",
+        applyToUniorg: uniorgAst => applyLogseqSpecificsToUniorgAst(uniorgAst, nestUnderHeadings),
+        extractFromUniorg: extractLogseqSpecificsFromUniorgAst
+    };
+}
+function headingProperty(level) {
+    return { type: "node-property", key: "heading", value: String(level) };
+}
+function headingDrawer(level) {
+    return {
+        type: "property-drawer",
+        children: [headingProperty(level)],
+        contentsBegin: 0,
+        contentsEnd: 0
+    };
+}
+// org fixes the order below a headline: the planning line first, then a
+// single property drawer. :heading: therefore has to let the planning
+// line pass and join an existing drawer rather than displace either.
+// Returns whether the property has been placed on `node`.
+function placeHeadingProperty(node, level) {
+    if (node.type === "planning") {
+        return false;
+    }
+    if (node.type !== "property-drawer") {
+        return false;
+    }
+    ;
+    node.children.unshift(headingProperty(level));
+    return true;
+}
+// the page name of a [[page]] link destination, or null. The core
+// transform percent-encodes brackets in urls (an org link path cannot
+// hold them), so the destination arrives here already encoded.
+function pageRefUrlTarget(rawLink) {
+    const decoded = rawLink.replaceAll("%5B", "[").replaceAll("%5D", "]");
+    return /^\[\[(.+)\]\]$/.exec(decoded)?.[1] ?? null;
+}
+// Logseq md labeled page refs ([label]([[page]])) become org's
+// [[page][label]] description syntax. A page name containing a space is
+// not a valid CommonMark destination, so the ref travels as plain text;
+// without one remark parses it as a real link instead.
+function rewriteLabeledPageRefs(uniorgAst) {
+    visit(uniorgAst, "text", (node) => {
+        node.value = node.value.replace(/\[([^\]]+)\]\(\[\[([^\]]+)\]\]\)/g, "[[$2][$1]]");
+    });
+    visit(uniorgAst, "link", (node) => {
+        const page = pageRefUrlTarget(node.rawLink);
+        if (page === null) {
+            return;
+        }
+        node.linkType = "fuzzy";
+        node.rawLink = page;
+        node.path = page;
+    });
+}
+function toBlockHeadline(node, level) {
+    const blockHeadline = {
+        type: "headline",
+        level,
+        todoKeyword: null,
+        priority: null,
+        commented: false,
+        rawValue: "",
+        tags: [],
+        children: node.children
+    };
+    takeTaskMarker(blockHeadline);
+    return blockHeadline;
+}
+/**
+ * Applies Logseq-specific conventions to a uniorg AST: every heading gets
+ * a `:heading:` property drawer, and with `nestUnderHeadings` following
+ * paragraphs become child block headlines (in Logseq's org format every
+ * outline block is a headline).
+ * @param uniorgAst The uniorg AST to transform.
+ * @param nestUnderHeadings Nest content as child blocks. Default: `true`.
+ * @returns The Logseq-flavored uniorg AST.
+ */
+export function applyLogseqSpecificsToUniorgAst(uniorgAst, nestUnderHeadings = true) {
+    rewriteLabeledPageRefs(uniorgAst);
+    const children = uniorgAst.children;
+    const result = [];
+    let currentLevel = 0;
+    // level of a headline whose :heading: property still needs a home
+    let pending = null;
+    const separate = () => {
+        if (!nestUnderHeadings) {
+            result.push({ type: "text", value: "\n" });
+        }
+    };
+    // no drawer took the property: give it one of its own
+    const settle = () => {
+        if (pending === null) {
+            return;
+        }
+        result.push(headingDrawer(pending));
+        pending = null;
+        separate();
+    };
+    for (const node of children) {
+        if (node.type === "headline") {
+            settle();
+            const headline = node;
+            currentLevel = headline.level;
+            takeTaskMarker(headline);
+            result.push(node);
+            pending = headline.level;
+            continue;
+        }
+        if (pending !== null) {
+            if (placeHeadingProperty(node, pending)) {
+                pending = null;
+                result.push(node);
+                separate();
+                continue;
+            }
+            if (node.type !== "planning") {
+                settle();
+            }
+        }
+        result.push(nestUnderHeadings && node.type === "paragraph"
+            ? toBlockHeadline(node, currentLevel + 1)
+            : node);
+    }
+    settle();
+    uniorgAst.children = result;
+    return uniorgAst;
+}
+// Logseq md keeps TODO/DONE as leading text markers and priorities as
+// [#A] text; in org they are the headline's TODO keyword and priority
+// (other Logseq markers like DOING are not org keywords and simply
+// stay in the title text)
+function takeTaskMarker(headline) {
+    const first = headline.children[0];
+    if (first?.type !== "text") {
+        return;
+    }
+    const marker = /^(TODO|DONE) (?:\[#([A-Z])\] )?/.exec(first.value);
+    if (!marker) {
+        return;
+    }
+    headline.todoKeyword = marker[1];
+    if (marker[2]) {
+        headline.priority = marker[2];
+    }
+    first.value = first.value.slice((marker[0] ?? "").length);
+}
+/**
+ * Extracts Logseq-specific conventions from a uniorg AST: headlines with
+ * a `:heading:` property become plain headings of that level, headlines
+ * without one are outline blocks and become paragraphs.
+ * @param uniorgAst The Logseq-flavored uniorg AST to transform.
+ * @returns The generic uniorg AST.
+ */
+function extractLogseqSpecificsFromUniorgAst(uniorgAst) {
+    extractInParent(uniorgAst);
+    repairHighlights(uniorgAst);
+    fuzzyLinksToPageRefs(uniorgAst);
+    markHiccupParagraphs(uniorgAst);
+    return uniorgAst;
+}
+// Logseq highlight markup (^^words^^) re-parses as a caret plus a
+// superscript; merge the pieces back into literal text
+function repairHighlights(uniorgAst) {
+    visit(uniorgAst, node => {
+        const children = node.children;
+        if (!children) {
+            return;
+        }
+        for (let i = 0; i + 1 < children.length; i++) {
+            const current = children[i];
+            const next = children[i + 1];
+            if (current?.type === "text" &&
+                current.value?.endsWith("^") &&
+                next?.type === "superscript") {
+                current.value += `^${toString(next)}`;
+                children.splice(i + 1, 1);
+                i--;
+            }
+        }
+    });
+}
+// Logseq page and block references: [[page]] stays a wikilink,
+// [[page][label]] becomes [label]([[page]]), [[((uuid))][label]]
+// becomes [label](((uuid))) — emitted unescaped via verbatim-inline
+const BLOCK_REF_RE = /^\(\(.*\)\)$/;
+function pageRefValue(label, target) {
+    if (!label) {
+        return `[[${target}]]`;
+    }
+    if (BLOCK_REF_RE.test(target)) {
+        return `[${label}](${target})`;
+    }
+    return `[${label}]([[${target}]])`;
+}
+function fuzzyLinksToPageRefs(uniorgAst) {
+    visit(uniorgAst, "link", (node, index, parent) => {
+        const target = node.rawLink ?? "";
+        const isBlockRef = BLOCK_REF_RE.test(target);
+        if ((node.linkType !== "fuzzy" && !isBlockRef) || !parent) {
+            return undefined;
+        }
+        const label = node.children.length ? toString(node) : "";
+        const value = pageRefValue(label, target);
+        parent.children[index] = {
+            type: "verbatim-inline",
+            value
+        };
+        return undefined;
+    });
+}
+// hiccup blocks ([:tag …]) are Logseq markup, not links or footnotes; a
+// verbatim-inline node keeps the brackets unescaped in Markdown output
+function markHiccupParagraphs(uniorgAst) {
+    visit(uniorgAst, "paragraph", (node) => {
+        const text = toString(node);
+        if (text.startsWith("[:")) {
+            node.children = [
+                { type: "verbatim-inline", value: text.replace(/\n$/, "") }
+            ];
+        }
+    });
+}
+function extractInParent(parent) {
+    const children = parent.children;
+    for (let i = 0; i < children.length; i++) {
+        const node = children[i];
+        if (!node) {
+            continue;
+        }
+        if (node.type === "section") {
+            extractInParent(node);
+            continue;
+        }
+        if (node.type !== "headline") {
+            continue;
+        }
+        const headline = node;
+        if (headline.todoKeyword) {
+            // back to Logseq md's text conventions (TODO [#A] Ship it);
+            // verbatim-inline keeps the [#A] brackets unescaped
+            const priority = headline.priority ? `[#${headline.priority}] ` : "";
+            headline.children.unshift({
+                type: "verbatim-inline",
+                value: `${headline.todoKeyword} ${priority}`
+            });
+            headline.todoKeyword = null;
+            headline.priority = null;
+        }
+        // a planning line sits between the headline and its drawer
+        const drawerIndex = children[i + 1]?.type === "planning" ? i + 2 : i + 1;
+        const heading = takeHeadingProperty(children, drawerIndex);
+        if (heading !== null) {
+            headline.level = heading;
+        }
+        else {
+            // a block headline (no :heading:) is outline structure only; its
+            // title is the block's content
+            children[i] = {
+                type: "paragraph",
+                children: headline.children,
+                contentsBegin: 0,
+                contentsEnd: 0
+            };
+        }
+    }
+}
+// removes the heading property from a drawer at `index` (and the drawer
+// itself if that empties it); returns the heading level or null
+function takeHeadingProperty(children, index) {
+    const drawer = children[index];
+    if (drawer?.type !== "property-drawer") {
+        return null;
+    }
+    const properties = drawer.children;
+    const heading = properties.find(property => property.key === "heading");
+    if (!heading) {
+        return null;
+    }
+    const remaining = properties.filter(property => property !== heading);
+    if (remaining.length) {
+        ;
+        drawer.children = remaining;
+    }
+    else {
+        children.splice(index, 1);
+    }
+    return parseInt(heading.value, 10) || null;
+}

package/dist/presets/obsidian.d.ts

@@ -0,0 +1,6 @@
+import type { Preset } from "./types.js";
+/**
+ * Obsidian dialect preset: `[[Page]]` / `[[Page|alias]]` wikilinks map
+ * to org fuzzy links (`[[Page]]` / `[[Page][alias]]`).
+ */
+export declare function obsidian(): Preset;

package/dist/presets/obsidian.js

@@ -0,0 +1,40 @@
+import { visit } from "unist-util-visit";
+import { toString } from "orgast-util-to-string";
+/**
+ * Obsidian dialect preset: `[[Page]]` / `[[Page|alias]]` wikilinks map
+ * to org fuzzy links (`[[Page]]` / `[[Page][alias]]`).
+ */
+export function obsidian() {
+    return {
+        name: "obsidian",
+        applyToUniorg: rewriteAliasedWikilinks,
+        extractFromUniorg: fuzzyLinksToWikilinks
+    };
+}
+// md→org: a wikilink travels as plain text; org already reads `[[Page]]`
+// as a fuzzy link, only the `[[Page|alias]]` form needs rewriting to
+// org's `[[Page][alias]]` description syntax
+function rewriteAliasedWikilinks(uniorgAst) {
+    visit(uniorgAst, "text", (node) => {
+        node.value = node.value.replace(/\[\[([^\][|]+)\|([^\][]+)\]\]/g, "[[$1][$2]]");
+    });
+    return uniorgAst;
+}
+// org→md: fuzzy links become wikilink text; a verbatim-inline node keeps
+// the brackets unescaped in the Markdown output
+function fuzzyLinksToWikilinks(uniorgAst) {
+    visit(uniorgAst, "link", (node, index, parent) => {
+        if (node.linkType !== "fuzzy") {
+            return undefined;
+        }
+        const description = node.children.length ? toString(node) : "";
+        parent.children[index] = {
+            type: "verbatim-inline",
+            value: description
+                ? `[[${node.rawLink}|${description}]]`
+                : `[[${node.rawLink}]]`
+        };
+        return undefined;
+    });
+    return uniorgAst;
+}

package/dist/presets/registry.d.ts

@@ -0,0 +1,8 @@
+import type { Preset } from "./types.js";
+/**
+ * Instantiates a preset by name.
+ * @param presetName Preset name, or `undefined` for no preset.
+ * @returns The preset, or `undefined` when no name was given.
+ * @throws If the name is not a known preset.
+ */
+export declare function createPreset(presetName: string | undefined): Preset | undefined;

package/dist/presets/registry.js

@@ -0,0 +1,25 @@
+import { logseq } from "./logseq.js";
+import { obsidian } from "./obsidian.js";
+// the one place a dialect preset is registered; both adapters (CLI and
+// Web UI) resolve names through here so they cannot drift apart
+const PRESETS = {
+    logseq: () => logseq(),
+    obsidian: () => obsidian()
+};
+const PRESET_NAMES = Object.keys(PRESETS);
+/**
+ * Instantiates a preset by name.
+ * @param presetName Preset name, or `undefined` for no preset.
+ * @returns The preset, or `undefined` when no name was given.
+ * @throws If the name is not a known preset.
+ */
+export function createPreset(presetName) {
+    if (!presetName) {
+        return undefined;
+    }
+    const factory = PRESETS[presetName];
+    if (!factory) {
+        throw new Error(`Unknown preset '${presetName}'. Available presets: ${PRESET_NAMES.join(", ")}`);
+    }
+    return factory();
+}

package/dist/presets/types.d.ts

@@ -0,0 +1,12 @@
+import type { OrgData } from "uniorg";
+/**
+ * A dialect preset: transforms applied on top of the dialect-agnostic core.
+ * `applyToUniorg` runs in the md→org pipeline after the generic transform;
+ * `extractFromUniorg` runs in the org→md pipeline before the generic
+ * transform, normalizing dialect conventions back to generic uniorg.
+ */
+export interface Preset {
+    name: string;
+    applyToUniorg?: (uniorgAst: OrgData) => OrgData;
+    extractFromUniorg?: (uniorgAst: OrgData) => OrgData;
+}

package/dist/presets/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,112 @@
+{
+  "name": "@remigius42/morg",
+  "version": "0.4.0",
+  "description": "Bidirectional Markdown ↔ Org-mode converter with round-trip convergence",
+  "keywords": [
+    "org-mode",
+    "markdown",
+    "converter",
+    "unified",
+    "remark",
+    "uniorg",
+    "logseq",
+    "obsidian"
+  ],
+  "license": "GPL-3.0-or-later",
+  "author": "Andreas Remigius Schmidt",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/remigius42/morg.git"
+  },
+  "bugs": "https://github.com/remigius42/morg/issues",
+  "homepage": "https://github.com/remigius42/morg#readme",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "morg": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "prepare": "husky",
+    "prepack": "npm run build",
+    "version": "node scripts/release-changelog.mjs && git add CHANGELOG.md",
+    "build": "tsc -p tsconfig.build.json",
+    "build:web": "vite build web",
+    "dev:web": "vite web",
+    "preview:web": "vite preview web --port 4173 --strictPort",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "lint": "npm run lint:prettier && npm run lint:cspell && npm run lint:markdown && npm run lint:eslint && npm run lint:knip && npm run typecheck",
+    "lint:knip": "knip",
+    "lint:packaging": "attw --pack . --ignore-rules cjs-resolves-to-esm",
+    "lint:prettier": "prettier --no-error-on-unmatched-pattern --ignore-unknown --list-different '**/*'",
+    "lint:cspell": "cspell --dot --no-must-find-files --no-progress '**/*'",
+    "lint:markdown": "markdownlint-cli2 '**/*.md' '!node_modules/**'",
+    "lint:eslint": "eslint --max-warnings=0 '**/*.{ts,mts,js,mjs}'",
+    "lint:fix": "npm run lint:fix:prettier && npm run lint:fix:eslint",
+    "lint:fix:prettier": "prettier --write '**/*'",
+    "lint:fix:eslint": "eslint --fix '**/*.{ts,mts,js}'",
+    "test:unit": "vitest",
+    "test:unit:ci": "vitest run --reporter default --coverage",
+    "test:coverage": "vitest run --coverage",
+    "test:e2e": "playwright test",
+    "test:e2e:chromium": "playwright test --project=chromium",
+    "test:e2e:report": "playwright show-report tests/e2e/reports/html"
+  },
+  "dependencies": {
+    "@types/mdast": "^4.0.4",
+    "orgast-util-to-string": "^1.1.0",
+    "remark-frontmatter": "^5.0.0",
+    "remark-gfm": "^4.0.1",
+    "remark-math": "^6.0.0",
+    "remark-parse": "^11.0.0",
+    "remark-stringify": "^11.0.0",
+    "smol-toml": "^1.8.0",
+    "unified": "^11.0.5",
+    "uniorg": "^1.4.0",
+    "uniorg-parse": "^3.2.2",
+    "uniorg-stringify": "^1.4.0",
+    "unist-util-visit": "^5.0.0",
+    "yaml": "^2.9.0"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.5",
+    "@axe-core/playwright": "^4.13.0",
+    "@commitlint/cli": "^21.2.2",
+    "@commitlint/config-conventional": "^21.2.2",
+    "@eslint/js": "^10.0.1",
+    "@picocss/pico": "^2.1.1",
+    "@playwright/test": "^1.63.0",
+    "@types/node": "^24.3.0",
+    "@types/unist": "^3.0.3",
+    "@vitest/coverage-v8": "^5.0.0",
+    "cspell": "^10.2.2",
+    "eslint": "^10.10.0",
+    "happy-dom": "^20.14.3",
+    "husky": "^9.1.7",
+    "knip": "^6.35.1",
+    "lint-staged": "^17.5.1",
+    "markdownlint-cli2": "^0.23.2",
+    "prettier": "^3.6.2",
+    "tsx": "^4.23.13",
+    "typescript": "^5.9.2",
+    "typescript-eslint": "^8.42.0",
+    "vite": "^8.2.2",
+    "vitest": "^5.0.0"
+  }
+}