@remigius42/morg 0.4.0

package/README.md

@@ -0,0 +1,267 @@
+# [morg](https://github.com/remigius42/morg)
+
+Copyright 2026 [Andreas Remigius Schmidt](https://github.com/remigius42)
+
+[![Version](https://img.shields.io/github/v/tag/remigius42/morg?label=version)](https://github.com/remigius42/morg/blob/main/CHANGELOG.md)
+[![License](https://img.shields.io/badge/license-GPL--3.0--or--later-blue.svg)](LICENSE)
+[![CI](https://github.com/remigius42/morg/actions/workflows/ci.yml/badge.svg)](https://github.com/remigius42/morg/actions/workflows/ci.yml)
+![Node](https://img.shields.io/badge/node-%3E%3D20-lightgrey.svg)
+[![Codacy grade](https://app.codacy.com/project/badge/Grade/da438d1b90e74d40b03f9fa5b3eca221)](https://app.codacy.com/gh/remigius42/morg/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade)
+[![Codacy coverage](https://app.codacy.com/project/badge/Coverage/da438d1b90e74d40b03f9fa5b3eca221)](https://app.codacy.com/gh/remigius42/morg/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_coverage)
+
+Bidirectional **Markdown ↔ Org-mode** converter, built on the
+[unified](https://unifiedjs.com/) ecosystem
+([remark](https://github.com/remarkjs/remark) for Markdown,
+[uniorg](https://github.com/rasendubi/uniorg) for Org).
+
+morg treats Org as a canonical plain-text format and Markdown (Obsidian,
+generic) as the interop surface. Dialect conventions — such as
+[Logseq](https://docs.logseq.com/)'s `heading::` properties and outline nesting
+— are supported via presets.
+
+## Round-trip convergence
+
+Strict byte-losslessness between the two formats is impossible. morg's
+guarantee is to be **semantically faithful and convergent** instead
+(see [ADR 0001](docs/adr/0001-convergence-over-losslessness.md)):
+
+- One round trip (`md → org → md` or `org → md → org`) may normalize formatting,
+  but its output is a fixed point: converting again reproduces it byte-for-byte.
+- Input already in canonical form is a round-trip identity. Opt-in
+  `recordStyle` widens that set: a file whose bullet, emphasis, fence
+  and rule markers are used consistently has them recorded in the org
+  file and restored on the way back, so it is left untouched
+  ([ADR 0004](docs/adr/0004-record-source-markdown-style.md)).
+- `md → org` preserves Markdown-only constructs ("md-isms") as `morg_`-prefixed
+  org properties; `org → md` serializes Org-only constructs ("org-isms") as
+  `key:: value` conventions ([ADR
+  0002](docs/adr/0002-mdism-property-namespace.md)).
+- The few constructs that cannot be carried are documented in the
+  [mapping reference](docs/mappings.md) and reported as warnings.
+
+Round-trip fixture tests are the backbone of the test suite
+(`tests/roundtrip.spec.ts`). The Web UI is covered by vitest specs under
+happy-dom and by a Playwright suite (`tests/e2e/`) that drives the built
+pages in Chromium and WebKit, including axe accessibility audits in both
+color schemes.
+
+## Usage
+
+### Web UI
+
+Try morg without installing anything at
+[morg.binarypoetry.ch](https://morg.binarypoetry.ch) — all conversion
+happens in your browser, nothing is uploaded (see [ADR
+0003](docs/adr/0003-client-side-web-ui-on-github-pages.md)). The
+chrome-less embed page (`/embed.html`, optionally with
+`?theme=dark|light`) can be iframed into other sites. It posts its
+content height to the host on every change, so the frame can follow it
+rather than scrolling inside a page that already scrolls:
+
+```js
+addEventListener("message", event => {
+  if (event.origin !== "https://morg.binarypoetry.ch") return
+  if (event.data?.type === "morg:height") {
+    frame.style.height = `${event.data.height}px`
+  }
+})
+```
+
+Give the frame at least 768px of width if you can — below that the
+input and output stack, which doubles its height. `allow="clipboard-write"`
+lets the Copy button use the clipboard rather than falling back to
+selecting the output.
+
+Besides pasting, a file can be opened with the picker or dropped
+anywhere on the page — a `.toml` lands in the config panel, a document
+in the input, and the conversion direction follows the extension. Drop
+both at once and each goes where it belongs; an overlay names what is
+accepted while a drag is in flight, and anything that turns out not to
+be text is named in the warning list rather than loaded. The result can
+be copied or saved with the Copy and Download buttons; a normalized file
+is saved as `notes.normalized.org`, and switching to a direction that no
+longer reads the opened file falls back to a generic name, so neither
+lands on top of its own source. Files are read and written by the
+browser itself; this is not an upload.
+
+Typing is converted once you pause, not once per keystroke, and the
+conversion itself runs in a web worker, so the page stays responsive
+even while a large document is being converted. Copy and Download are
+unavailable for as long as a conversion is running, so they can never
+save the previous document's output.
+
+### CLI
+
+Run it without installing, or install it globally:
+
+```bash
+npx @remigius42/morg --input notes.md --output notes.org
+npm install --global @remigius42/morg
+```
+
+```bash
+# Formats inferred from file extensions
+morg --input notes.md --output notes.org
+
+# stdin/stdout with explicit format
+echo "# Hello" | morg --from markdown
+
+# Apply a dialect preset
+morg --input page.md --output page.org --preset logseq
+
+# Dropped constructs are reported on stderr; -s / --silent suppresses.
+# Boolean flags take an optional value, so --silent false overrides a
+# morg.toml that sets it
+morg --input notes.md --output notes.org --silent
+
+# Record the source's own markdown style (bullet, emphasis, fence,
+# rule) in the org file, so the return trip restores it instead of
+# canonicalizing it; markers used inconsistently warn and are skipped
+morg --input notes.md --output notes.org --record-style
+
+# Normalize to canonical form (same format in and out); this
+# canonicalizes — the one-time reformat a first conversion would
+# apply anyway (ADR 0001) — it is not a style formatter like prettier
+morg normalize --input notes.org --output notes.org
+```
+
+### Configuration file
+
+Options can live in a `morg.toml` (auto-discovered in the working
+directory, or passed via `--config path`). Precedence: CLI flags >
+config file > defaults:
+
+```toml
+preset = "logseq"
+
+[orgToMarkdown.markdownStyle]
+emphasis = "_" # align with prettier
+```
+
+The full reference — all sections and compatibility snippets for
+prettier and mdformat — is in
+[docs/CONFIGURATION.md](docs/CONFIGURATION.md).
+
+### Library
+
+```bash
+npm install @remigius42/morg
+```
+
+morg is ESM-only and ships its own type declarations:
+
+```ts
+import {
+  convertMarkdownToOrg,
+  convertOrgToMarkdown,
+  logseq
+} from "@remigius42/morg"
+
+const org = convertMarkdownToOrg("# Hello\n\nWorld.")
+const md = convertOrgToMarkdown(org)
+
+// Logseq dialect
+const logseqOrg = convertMarkdownToOrg(markdown, { preset: logseq() })
+```
+
+Options (flags accept `boolean` or a per-construct `Record<string, boolean>`):
+
+- `convertMarkdownToOrg(md, { preserveMdisms, interpretHtml, recordStyle,
+preset })` —
+  `preserveMdisms` default `true`; `interpretHtml` (default `false`,
+  CLI `--interpret-html`) interprets the HTML vocabulary morg itself
+  emits under `useHtml` (bare `<u>`, `<sup>`, `<sub>`, `<dl>`) as
+  native Org constructs — the inverse of `useHtml`: with both enabled
+  the round trip is lossless, with `interpretHtml` alone it converges
+  away from HTML (cleanup mode); other HTML preserves as usual;
+  `recordStyle` (default `false`, CLI `--record-style`) records the
+  document-level markdown style as a `#+MORG_MARKDOWN_STYLE:` keyword so the
+  round trip restores it (ADR 0004)
+- `convertOrgToMarkdown(org, { preserveOrgisms, useHtml, taskCheckboxes,
+preset })` — `preserveOrgisms` default `true`; `useHtml` (default
+  `false`) renders org-only markup as raw HTML (`<u>`, `<sup>`, `<sub>`,
+  `<dl>`) instead of keeping it verbatim; `taskCheckboxes` (default
+  `false`, CLI `--task-checkboxes`) is a lossy export mode that maps
+  bare `TODO`/`DONE` leaf headlines to GFM task items (`- [ ]` /
+  `- [x]`) — headings become list items and do not restore on the
+  return trip; anything with priority, tags or content keeps its
+  heading and reports via `onWarning`
+- `logseq({ nestUnderHeadings })` — default `true`; content following a
+  heading nests as child blocks of that heading: paragraphs become child
+  headlines one level deeper (in Logseq org every outline block is a
+  headline), other constructs stay in the preceding block's body. The
+  reverse direction restores headings from `:heading:` properties and
+  turns plain block headlines back into paragraphs. Hiccup blocks
+  (`[:div …]`) pass through as plain text and are emitted unescaped in
+  Markdown. Logseq's own syntax maps both directions: `TODO`/`DONE`
+  text markers and `[#A]` priorities ↔ org keywords/priorities, page
+  references `[[page]]` and labeled forms `[label]([[page]])` ↔ org
+  fuzzy links `[[page][label]]`, block refs `[label](((uuid)))` ↔
+  `[[((uuid))][label]]`, and `^^highlight^^` markup survives verbatim
+  (it would otherwise re-parse as superscripts).
+- `obsidian()` — wikilinks `[[Page]]` / `[[Page|alias]]` ↔ org fuzzy links
+
+- `normalizeMarkdown(md, { preset })` / `normalizeOrg(org, { preset })`
+  (CLI: `morg normalize`) — one full round trip to morg's canonical
+  form, a fixed point. Canonicalization, not styling: org-isms and
+  md-isms are rewritten exactly as a conversion would rewrite them.
+  Normalize with the same preset/config you will convert with —
+  convergence is per-config (ADR 0002).
+
+- `markdownStyle: { bullet, emphasis, strong, fence, rule, ruleRepetition }`
+  (on `convertOrgToMarkdown` and `normalizeMarkdown`; CLI `--bullet`,
+  `--emphasis`, `--strong`, `--fence`, `--rule`, `--rule-repetition`)
+  — Markdown output style knobs. Defaults match prettier except emphasis (`*italic*`);
+  `--emphasis _` aligns fully with prettier. Canonical form is
+  per-config (ADR 0001): round trips must use the same style. Note
+  CommonMark/GFM prescribe no style — these defaults are morg's
+  canonical choices, not a standard.
+
+Both convert functions also accept `onWarning: message => …`, called for
+each construct dropped without an equivalent (e.g. image titles, LaTeX
+fragments). The CLI wires this to stderr unless `-s` / `--silent` is
+given; the library is silent unless a callback is passed.
+
+## Architecture
+
+Two pipelines, each with a two-phase transformation separating the
+dialect-agnostic core from dialect presets:
+
+```text
+md → org:  remark-parse → mdast→uniorg (core) → preset transforms → uniorg-stringify
+org → md:  uniorg-parse → preset extraction → uniorg→mdast (core) → remark-stringify
+```
+
+Formatting is controlled by shaping the AST (e.g. inserting newline text nodes),
+not by custom stringifier handlers — the default, battle-tested stringifiers do
+the rendering.
+
+Project vocabulary lives in [CONTEXT.md](CONTEXT.md); design decisions in
+[docs/adr/](docs/adr/).
+
+## Status
+
+The core conversion surface is feature-complete and validated against
+real-world Logseq org vaults (edge cases found there live on as
+anonymized fixtures, e.g. `tests/fixtures/logseq-vault.org`); the
+client-side [Web UI](https://morg.binarypoetry.ch) is deployed from
+`main`. The npm package is `@remigius42/morg` — the bare `morg` name is
+taken — and pushing a `v*` tag publishes it. Most of the code is
+written with an AI coding agent under human direction, test-first and
+CI-gated — see
+the [contributing guide](CONTRIBUTING.md#development-process).
+
+How each construct maps — including deliberate normalizations and
+documented drops — is covered in the
+[mapping reference](docs/mappings.md). Notable changes are tracked in
+the [changelog](CHANGELOG.md).
+
+## Contributing
+
+See the [contributing guide](CONTRIBUTING.md) for setup, conventions
+and the test-first workflow; participation is governed by the
+[code of conduct](CODE_OF_CONDUCT.md).
+
+## License
+
+[GPL-3.0-or-later](LICENSE) (required by the uniorg dependencies).

package/dist/cli/args.d.ts

@@ -0,0 +1,15 @@
+export interface CliArgs {
+    normalize: boolean;
+    fromFormat: string | undefined;
+    toFormat: string | undefined;
+    inputFile: string | undefined;
+    outputFile: string | undefined;
+    presetName: string | undefined;
+    silent: boolean | undefined;
+    taskCheckboxes: boolean | undefined;
+    interpretHtml: boolean | undefined;
+    recordStyle: boolean | undefined;
+    configPath: string | undefined;
+    markdownStyle: Record<string, string>;
+}
+export declare function parseArgs(args: string[]): CliArgs;

package/dist/cli/args.js

@@ -0,0 +1,105 @@
+import { CliError } from "./error.js";
+export function parseArgs(args) {
+    // `morg normalize` canonicalizes in place of converting: same format
+    // in and out, one full round trip (see ADR 0001)
+    const normalize = args[0] === "normalize";
+    if (normalize) {
+        args.shift();
+    }
+    const parsed = {
+        normalize,
+        fromFormat: undefined,
+        toFormat: undefined,
+        inputFile: undefined,
+        outputFile: undefined,
+        presetName: undefined,
+        silent: undefined,
+        taskCheckboxes: undefined,
+        interpretHtml: undefined,
+        recordStyle: undefined,
+        configPath: undefined,
+        markdownStyle: {}
+    };
+    parseFlags(parsed, args);
+    return parsed;
+}
+const VALUE_FLAGS = new Set([
+    "--config",
+    "--bullet",
+    "--emphasis",
+    "--strong",
+    "--fence",
+    "--rule",
+    "--rule-repetition",
+    "--from",
+    "--to",
+    "--input",
+    "--output",
+    "--preset"
+]);
+const BOOLEAN_FLAGS = new Map([
+    ["-s", "silent"],
+    ["--silent", "silent"],
+    ["--task-checkboxes", "taskCheckboxes"],
+    ["--interpret-html", "interpretHtml"],
+    ["--record-style", "recordStyle"]
+]);
+// a following flag means the value was forgotten; a lone `-` is a legitimate
+// bullet or rule character, so only recognized flag tokens disqualify
+function takeValue(args, index) {
+    const flag = args[index];
+    const value = args[index + 1];
+    if (value === undefined ||
+        VALUE_FLAGS.has(value) ||
+        BOOLEAN_FLAGS.has(value)) {
+        throw new CliError(`${flag} requires a value`);
+    }
+    return value;
+}
+function parseFlags(parsed, args) {
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i] ?? "";
+        // boolean flags take an optional `true`/`false`; bare means true
+        const option = BOOLEAN_FLAGS.get(arg);
+        if (option) {
+            const value = args[i + 1];
+            if (value === "true" || value === "false") {
+                i++;
+            }
+            parsed[option] = value !== "false";
+            continue;
+        }
+        switch (arg) {
+            case "--config":
+                parsed.configPath = takeValue(args, i++);
+                break;
+            case "--bullet":
+            case "--emphasis":
+            case "--strong":
+            case "--fence":
+            case "--rule":
+                parsed.markdownStyle[arg.slice(2)] = takeValue(args, i++);
+                break;
+            case "--rule-repetition":
+                parsed.markdownStyle.ruleRepetition = takeValue(args, i++);
+                break;
+            case "--from":
+                parsed.fromFormat = takeValue(args, i++);
+                break;
+            case "--to":
+                parsed.toFormat = takeValue(args, i++);
+                break;
+            case "--input":
+                parsed.inputFile = takeValue(args, i++);
+                break;
+            case "--output":
+                parsed.outputFile = takeValue(args, i++);
+                break;
+            case "--preset":
+                parsed.presetName = takeValue(args, i++);
+                break;
+            default:
+                throw new CliError(`Unknown argument: ${arg}`);
+        }
+    }
+}

package/dist/cli/configFile.d.ts

@@ -0,0 +1,2 @@
+import { type MorgConfig } from "../config.js";
+export declare function loadConfig(configPath: string | undefined): MorgConfig;

package/dist/cli/configFile.js

@@ -0,0 +1,18 @@
+import * as fs from "node:fs";
+import { parseConfig } from "../config.js";
+import { CliError } from "./error.js";
+// morg.toml: precedence is CLI > config > defaults
+export function loadConfig(configPath) {
+    const resolvedConfigPath = configPath ?? (fs.existsSync("morg.toml") ? "morg.toml" : undefined);
+    if (!resolvedConfigPath) {
+        return {};
+    }
+    try {
+        return parseConfig(fs.readFileSync(resolvedConfigPath, "utf8"));
+    }
+    catch (error) {
+        throw new CliError(`Error reading ${resolvedConfigPath}:`, {
+            cause: error
+        });
+    }
+}

package/dist/cli/conversion.d.ts

@@ -0,0 +1,11 @@
+import type { MorgConfig } from "../config.js";
+import type { MarkdownStyleOptions } from "../options.js";
+import type { Preset } from "../presets/types.js";
+import type { CliArgs } from "./args.js";
+export declare function buildConversionOptions(cli: CliArgs, config: MorgConfig, preset: Preset | undefined): {
+    mdToOrgOptions: import("../options.js").MarkdownToOrgOptions;
+    orgToMdOptions: import("../options.js").OrgToMarkdownOptions & {
+        markdownStyle: MarkdownStyleOptions;
+    };
+};
+export declare function convert(inputContent: string, fromFormat: string, normalize: boolean, cli: CliArgs, config: MorgConfig, preset: Preset | undefined): string;

package/dist/cli/conversion.js

@@ -0,0 +1,50 @@
+import { convertMarkdownToOrg } from "../markdownToOrg.js";
+import { convertOrgToMarkdown } from "../orgToMarkdown.js";
+import { normalizeMarkdown, normalizeOrg } from "../normalize.js";
+import { buildConversionOptions as layerOptions } from "../conversionOptions.js";
+import { CliError } from "./error.js";
+export function buildConversionOptions(cli, config, preset) {
+    // an explicit --silent wins over the config; dropped constructs are
+    // reported on stderr unless it ends up on
+    const silent = cli.silent ?? config.silent ?? false;
+    const onWarning = silent
+        ? undefined
+        : (message) => console.error(`morg: ${message}`);
+    // style flags arrive as strings; the numeric one needs converting
+    const markdownStyle = {
+        ...cli.markdownStyle,
+        ...(cli.markdownStyle.ruleRepetition !== undefined && {
+            ruleRepetition: Number(cli.markdownStyle.ruleRepetition)
+        })
+    };
+    return layerOptions({
+        taskCheckboxes: cli.taskCheckboxes,
+        interpretHtml: cli.interpretHtml,
+        recordStyle: cli.recordStyle,
+        markdownStyle
+    }, config, {
+        preset,
+        onWarning,
+        ...(config.orgismKeys && { orgismKeys: config.orgismKeys })
+    });
+}
+export function convert(inputContent, fromFormat, normalize, cli, config, preset) {
+    try {
+        const { mdToOrgOptions, orgToMdOptions } = buildConversionOptions(cli, config, preset);
+        if (normalize) {
+            return fromFormat === "markdown"
+                ? normalizeMarkdown(inputContent, {
+                    ...mdToOrgOptions,
+                    ...orgToMdOptions
+                })
+                : normalizeOrg(inputContent, { ...mdToOrgOptions, ...orgToMdOptions });
+        }
+        if (fromFormat === "markdown") {
+            return convertMarkdownToOrg(inputContent, mdToOrgOptions);
+        }
+        return convertOrgToMarkdown(inputContent, orgToMdOptions);
+    }
+    catch (error) {
+        throw new CliError("Conversion error:", { cause: error });
+    }
+}

package/dist/cli/error.d.ts

@@ -0,0 +1,2 @@
+export declare class CliError extends Error {
+}

package/dist/cli/error.js

@@ -0,0 +1,4 @@
+// user-facing CLI failure; the executable entry maps it to stderr and
+// exit code 1 — helpers throw instead of exiting so they stay testable
+export class CliError extends Error {
+}

package/dist/cli/formats.d.ts

@@ -0,0 +1,3 @@
+import type { CliArgs } from "./args.js";
+export declare function inferFormats(cli: CliArgs): [fromFormat: string | undefined, toFormat: string | undefined];
+export declare function validateFormats(fromFormat: string | undefined, toFormat: string | undefined, normalize: boolean): asserts fromFormat is string;

package/dist/cli/formats.js

@@ -0,0 +1,46 @@
+import { CliError } from "./error.js";
+import { formatFromFileName } from "../fileNames.js";
+export function inferFormats(cli) {
+    let { fromFormat, toFormat } = cli;
+    // Infer formats from file extensions first
+    if (cli.inputFile && !fromFormat) {
+        fromFormat = formatFromFileName(cli.inputFile);
+    }
+    if (cli.outputFile && !toFormat) {
+        toFormat = formatFromFileName(cli.outputFile);
+    }
+    return inferMissingFormat(cli.normalize, fromFormat, toFormat);
+}
+// Infer missing format based on the other
+function inferMissingFormat(normalize, fromFormat, toFormat) {
+    if (normalize) {
+        // mirror whichever side is known; a conflict between the two is left
+        // intact for validateFormats to reject rather than silently overwritten
+        fromFormat = fromFormat ?? toFormat;
+        toFormat = toFormat ?? fromFormat;
+    }
+    else if (fromFormat && !toFormat) {
+        toFormat = fromFormat === "markdown" ? "org" : "markdown";
+    }
+    else if (toFormat && !fromFormat) {
+        fromFormat = toFormat === "markdown" ? "org" : "markdown";
+    }
+    return [fromFormat, toFormat];
+}
+export function validateFormats(fromFormat, toFormat, normalize) {
+    if (!fromFormat || !toFormat) {
+        throw new CliError("Error: Could not determine conversion formats.\n" +
+            "Please specify --from and --to, or provide input/output files with .md or .org extensions.");
+    }
+    if (!["markdown", "org"].includes(fromFormat) ||
+        !["markdown", "org"].includes(toFormat)) {
+        throw new CliError(`Error: Unsupported format. Supported formats are 'markdown' and 'org'.`);
+    }
+    if (!normalize && fromFormat === toFormat) {
+        throw new CliError("Error: Source and target formats cannot be the same.");
+    }
+    if (normalize && fromFormat !== toFormat) {
+        throw new CliError("Error: normalize reads and writes the same format; " +
+            `got '${fromFormat}' and '${toFormat}'.`);
+    }
+}

package/dist/cli/presets.d.ts

@@ -0,0 +1,2 @@
+import type { Preset } from "../presets/types.js";
+export declare function resolvePreset(presetName: string | undefined): Preset | undefined;

package/dist/cli/presets.js

@@ -0,0 +1,10 @@
+import { createPreset } from "../presets/registry.js";
+import { CliError } from "./error.js";
+export function resolvePreset(presetName) {
+    try {
+        return createPreset(presetName);
+    }
+    catch (error) {
+        throw new CliError(`Error: ${error.message}`);
+    }
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+import * as fs from "node:fs";
+import { parseArgs } from "./cli/args.js";
+import { loadConfig } from "./cli/configFile.js";
+import { resolvePreset } from "./cli/presets.js";
+import { inferFormats, validateFormats } from "./cli/formats.js";
+import { convert } from "./cli/conversion.js";
+import { CliError } from "./cli/error.js";
+async function readInput(inputFile) {
+    if (inputFile) {
+        return fs.readFileSync(inputFile, "utf8");
+    }
+    // Read from stdin
+    return new Promise(resolve => {
+        const chunks = [];
+        process.stdin.on("data", chunk => {
+            chunks.push(chunk);
+        });
+        process.stdin.on("end", () => {
+            // decode once: a multi-byte character may straddle two chunks
+            resolve(Buffer.concat(chunks).toString("utf8"));
+        });
+    });
+}
+async function main() {
+    const cli = parseArgs(process.argv.slice(2));
+    const config = loadConfig(cli.configPath);
+    const preset = resolvePreset(cli.presetName ?? config.preset);
+    const [fromFormat, toFormat] = inferFormats(cli);
+    validateFormats(fromFormat, toFormat, cli.normalize);
+    const inputContent = await readInput(cli.inputFile);
+    const outputContent = convert(inputContent, fromFormat, cli.normalize, cli, config, preset);
+    if (cli.outputFile) {
+        fs.writeFileSync(cli.outputFile, outputContent, "utf8");
+    }
+    else {
+        console.log(outputContent);
+    }
+}
+main().catch((error) => {
+    if (error instanceof CliError) {
+        // helpers throw instead of exiting; this is the only exit point
+        if (error.cause !== undefined) {
+            console.error(error.message, error.cause);
+        }
+        else {
+            console.error(error.message);
+        }
+    }
+    else {
+        console.error("An unexpected error occurred:", error);
+    }
+    process.exit(1);
+});

package/dist/config.d.ts

@@ -0,0 +1,20 @@
+import type { MarkdownToOrgOptions, OrgToMarkdownOptions } from "./options.js";
+/**
+ * Shape of `morg.toml`. Sections mirror the library options objects;
+ * `preset` and `silent` mirror their CLI flags; `orgismKeys` is shared
+ * by both directions. Precedence: CLI > config > defaults.
+ */
+export interface MorgConfig {
+    preset?: string;
+    silent?: boolean;
+    orgismKeys?: Record<string, string>;
+    markdownToOrg?: Omit<MarkdownToOrgOptions, "preset" | "onWarning">;
+    orgToMarkdown?: Omit<OrgToMarkdownOptions, "preset" | "onWarning" | "orgismKeys">;
+}
+/**
+ * Parses a `morg.toml` source string. Unknown top-level keys are
+ * rejected so typos fail loudly instead of being silently ignored.
+ * @param source The TOML source text.
+ * @returns The parsed configuration.
+ */
+export declare function parseConfig(source: string): MorgConfig;

package/dist/config.js

@@ -0,0 +1,22 @@
+import { parse as parseToml } from "smol-toml";
+const KNOWN_KEYS = new Set([
+    "preset",
+    "silent",
+    "orgismKeys",
+    "markdownToOrg",
+    "orgToMarkdown"
+]);
+/**
+ * Parses a `morg.toml` source string. Unknown top-level keys are
+ * rejected so typos fail loudly instead of being silently ignored.
+ * @param source The TOML source text.
+ * @returns The parsed configuration.
+ */
+export function parseConfig(source) {
+    const parsed = parseToml(source);
+    const unknown = Object.keys(parsed).filter(key => !KNOWN_KEYS.has(key));
+    if (unknown.length) {
+        throw new Error(`Unknown config key(s): ${unknown.join(", ")}`);
+    }
+    return parsed;
+}