mdq-cli 0.1.1 → 0.1.2

package/README.md

@@ -1,187 +1,408 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/testomatio/explorbot/main/assets/logos/mdq/mdq-icon-bg-v2.png" alt="mdq" width="160">
+</p>
+
 # mdq
 
-Query and edit markdown with a selector language — jq, for markdown.
+Query, validate, extract, and update structured Markdown with a selector language. Like `jq` for Markdown.
 
-## Install
+## Usage examples
+
+```bash
+npx mdq-cli 'section("Overview")' generated.md                                      # validate
+npx mdq-cli 'section("API") table' --json README.md                                 # extract
+npx mdq-cli 'section("Tasks") list' --add-item 'Review docs' --in-place plan.md      # update
+```
+
+### Validate the structure of LLM-generated Markdown
+
+Use a selector as a structural assertion. The command prints the matching Markdown and exits with status `0` when the section exists, `1` when it does not exist, or `2` when the selector or input is invalid:
 
 ```bash
-npx mdq-cli 'h2' README.md     # no install
-npm install mdq-cli            # as a library
-npm install -g mdq-cli         # as a command
+npx mdq-cli 'section("Overview")' generated.md
 ```
 
-Node 18 or newer. Two dependencies: `marked` and `yaml`.
+Validate more specific structure by composing selectors:
 
-## Use
+```bash
+npx mdq-cli 'section("API") table' generated.md
+npx mdq-cli 'section("Examples") code[0]' generated.md
+```
+
+These queries check for an **Overview** section, a table inside **API**, and at least one fenced code block inside **Examples**. An unknown selector raises an error instead of silently matching nothing.
+
+The same validation can be scripted in JavaScript:
 
 ```js
+import { readFile } from 'node:fs/promises';
 import { mdq } from 'mdq-cli';
 
-mdq(readme).query('section("Install") code[0]').text();
-mdq(plan).comment(/^test/).nodes();
-mdq(doc).table().addRow({ Method: 'POST', Path: '/sessions' }).toString();
+const source = await readFile('generated.md', 'utf8');
+const doc = mdq(source);
+
+const valid =
+  doc.section('Overview').exists() &&
+  doc.query('section("API") table').exists() &&
+  doc.query('section("Examples") code[0]').exists();
+
+if (!valid) throw new Error('Generated Markdown does not match the required structure');
 ```
 
-There is a CLI too:
+### Extract data from structured Markdown
+
+Read a table as JSON from the CLI:
 
 ```bash
 npx mdq-cli 'section("API") table' --json README.md
 ```
 
-## The one rule
+Or extract typed structures through the JavaScript API:
+
+```js
+import { mdq } from 'mdq-cli';
+
+const endpoints = mdq(readme).query('section("API") table').rows();
+const metadata = mdq(plan).section('Metadata').entries();
+const testComments = mdq(doc).comment(/^test/).nodes();
+```
+
+### Update data in Markdown
+
+Append a row to a table and save the file in place:
+
+```bash
+npx mdq-cli 'section("API") table' \
+  --add-row '{"Method":"POST","Path":"/sessions"}' \
+  --in-place README.md
+```
+
+Or compose several edits in JavaScript:
+
+```js
+import { mdq } from 'mdq-cli';
+
+const updated = mdq(source)
+  .query('section("API") table')
+  .addRow({ Method: 'POST', Path: '/sessions' })
+  .query('section("Notes")')
+  .append('- Document the new endpoint\n')
+  .toString();
+```
+
+## Install
+
+```bash
+npx mdq-cli 'h2' README.md     # run without installing
+npm install mdq-cli            # use as a library
+npm install -g mdq-cli         # install the mdq-cli command globally
+```
+
+mdq requires Node.js 18 or newer. Its implementation libraries are described in [Implementation](#implementation).
+
+## Use mdq with coding agents
+
+Add this instruction to your project's `AGENTS.md`:
+
+```md
+When you need to inspect, validate, or edit structured Markdown, use `npx mdq-cli` selectors instead of parsing or rewriting the document manually; run `npx mdq-cli --help` for the available query and edit options.
+```
 
-**Reads narrow, writes return the document.**
+This gives an agent a deterministic CLI for checking generated documents, extracting structured content, and making targeted edits without rewriting unrelated Markdown.
 
-`mdq(source)` gives a `MarkdownQuery` — one class, holding the document and the set of
-blocks currently selected. `query()` and the sugar methods narrow that set. Every write
-returns a fresh `MarkdownQuery` over the edited document, so edits chain and end with
-`toString()`:
+## Core model
+
+**Reads narrow the selection; writes return the document.**
+
+`mdq(source)` returns a `MarkdownQuery`. It holds the complete document and the blocks currently selected from it. `query()` and the convenience methods narrow that selection. Every write returns a fresh `MarkdownQuery` over the edited document, so edits can be chained and finished with `toString()`:
 
 ```js
 mdq(source)
-  .query('section("API")').append('## Notes\n')
-  .query('blockquote[0]').remove()
+  .query('section("API")')
+  .append('## Notes\n')
+  .query('blockquote[0]')
+  .remove()
   .toString();
 ```
 
-`toString()` is always the whole document; `text()` is the markdown of the current
-selection.
+`toString()` always returns the whole document. `text()` returns the raw Markdown for only the current selection.
 
-## Selectors
+## CLI reference
 
-| Selector | Matches |
+```text
+mdq-cli [options] [selector] [file]
+```
+
+Square brackets in `mdq-cli [options] [selector] [file]` mean that an argument is optional; they are documentation notation, not characters to type.
+
+- `[selector]` is the query that chooses Markdown blocks.
+- `[file]` is the input file. When it is omitted, mdq reads the document from standard input.
+- `--in-place` is an output option for edits, not a replacement for `[file]`. It tells mdq to overwrite the input file instead of printing the edited document.
+
+```bash
+npx mdq-cli 'h2' README.md                    # read from a file
+cat README.md | npx mdq-cli 'h2'              # read from standard input
+npx mdq-cli 'comment(~"draft")' --remove README.md
+                                                  # print the edited document
+npx mdq-cli 'comment(~"draft")' --remove --in-place README.md
+                                                  # overwrite README.md
+```
+
+Only one edit option can be used per invocation. `--in-place` requires a file because there is no input file to overwrite when mdq reads from standard input.
+
+### Read options
+
+| Option | Result |
+| --- | --- |
+| `-j, --json` | Output selected table rows as JSON |
+| `-c, --count` | Print the number of matches |
+| `-t, --text` | Print unwrapped node text |
+| `--frontmatter` | Print YAML frontmatter as JSON; no selector is required |
+
+Without a read option, mdq prints the raw Markdown for the selection.
+
+### Edit options
+
+| Option | Effect |
 | --- | --- |
-| `section` | a heading and everything under it, until the next heading of the same or shallower depth |
-| `section1` … `section6` | the same, restricted to one heading depth |
-| `heading`, `h1` … `h6` | the heading line alone |
-| `paragraph` | a paragraph |
-| `table` | a GFM table |
-| `list` | a bullet or ordered list |
-| `item` | one item of a list |
-| `code` | a fenced code block |
-| `blockquote` | a `>` block |
-| `hr` | a thematic break |
-| `html` | an HTML block, matched on its raw text |
-| `comment` | an HTML comment, matched on its **inner** body |
+| `--remove` | Delete matched blocks |
+| `--replace <markdown>` | Replace matched blocks |
+| `--insert-before <markdown>` | Insert a sibling block before each match |
+| `--insert-after <markdown>` | Insert a sibling block after each match |
+| `--prepend <markdown>` | Insert at the start of each matched section or list |
+| `--append <markdown>` | Insert at the end of each matched section or list |
+| `--add-row <json>` | Append a row to each matched table |
+| `--add-item <text>` | Append an item to each matched list |
+| `--set <key=value>` | Set a `Key: value` entry; omit `=value` to delete the key |
+| `-i, --in-place` | Write the edited document back to the input file |
+
+Without `--in-place`, an edit prints the complete edited document to standard output. `--in-place` requires a file.
+
+### Use mdq in pipelines
+
+Because mdq reads from standard input when `[file]` is omitted, it can query generated Markdown without creating a temporary file:
+
+```bash
+generate-markdown | npx mdq-cli 'section("Summary")'
+```
 
-Text matchers go in parentheses, and `!` negates any of them:
+Pipe selected table rows as JSON into another data tool:
 
+```bash
+npx mdq-cli 'section("API") table' --json README.md |
+  jq -r '.[].Path'
 ```
-section("Install")      exact
-section(~"Inst")        contains
-section(/^inst/i)       regex, with its own flags
-section(!~"Draft")      negated
+
+Pipe a selected Markdown block to another command:
+
+```bash
+cat README.md |
+  npx mdq-cli 'section("Install")' |
+  markdownlint
 ```
 
-Index and slice with brackets, and compose with spaces to scope one selector inside
-another:
+Edits without `--in-place` print the complete edited document, so multiple mdq edits can be chained:
 
+```bash
+npx mdq-cli 'section("Deprecated")' --remove README.md |
+  npx mdq-cli 'section("Notes") list[0]' --add-item 'Reviewed' \
+  > README.updated.md
 ```
-heading[0]              first
-heading[-1]             last
+
+To replace the original file, prefer `--in-place`. Do not redirect output back to the same file being read, such as `... README.md > README.md`, because the shell truncates the file before mdq can read it.
+
+### Exit status
+
+| Status | Meaning |
+| --- | --- |
+| `0` | The query matched, the count completed, or the edit succeeded |
+| `1` | The selector matched nothing |
+| `2` | The command, selector, input file, or operation was invalid |
+
+`--count` exits with status `0`, including when the count is zero.
+
+## Selector reference
+
+| Selector | Matches |
+| --- | --- |
+| `section` | A heading and everything below it, up to the next heading of the same or shallower depth |
+| `section1` … `section6` | The same section range, restricted to one heading depth |
+| `heading`, `h1` … `h6` | The heading line only |
+| `paragraph` | A paragraph |
+| `table` | A GFM table |
+| `list` | A bullet or ordered list |
+| `item` | One list item |
+| `code` | A fenced code block |
+| `blockquote` | A `>` block |
+| `hr` | A thematic break |
+| `html` | An HTML block, matched against its raw text |
+| `comment` | An HTML comment, matched against its **inner** body |
+
+### Match text
+
+Put a text matcher in parentheses. Prefix any matcher with `!` to negate it.
+
+```text
+section("Install")      exact match
+section(~"Inst")        contains text
+section(/^inst/i)       regular expression, with its own flags
+section(!~"Draft")      negated match
+```
+
+### Select by index or slice
+
+Use brackets to select by position. Negative indexes count from the end, and slices follow Python-style `from:to` bounds.
+
+```text
+heading[0]              first heading
+heading[-1]             last heading
 blockquote[2:5]         a slice
-section("API") table    every table inside that section
 ```
 
-A leading `.` is accepted and ignored, so `.h2` works if that is your habit from jq.
+### Scope selectors
 
-An unknown selector throws `MdqSelectorError`, which carries the `index` of the offending
-character. It never silently matches nothing.
+Separate selectors with spaces to scope each selector inside the previous one:
 
-## Matchers as values
+```text
+section("API") table    every table inside the API section
+```
+
+A leading `.` is accepted and ignored, so `.h2` works if that is your habit from `jq`.
+
+An unknown selector throws `MdqSelectorError`. The error carries the `index` of the offending character; mdq never silently treats an unknown selector as an empty result.
+
+## Matchers as JavaScript values
 
-Passing a JavaScript value avoids escaping a dynamic string into a selector:
+Pass a JavaScript matcher value when building a selector string would require escaping dynamic input:
 
 ```js
-mdq(doc).query('section2', section.name);   // exact
-mdq(doc).heading(/^summary/i);              // regex, own flags
+mdq(doc).query('section2', section.name);   // exact string
+mdq(doc).heading(/^summary/i);              // RegExp with its own flags
 mdq(doc).item((text) => text.length > 80);  // predicate
 ```
 
-A `string` matches exactly, a `RegExp` honors its own flags, and a function is a predicate
-over the node's text. Every sugar method takes one: `section` `heading` `paragraph` `table`
-`list` `item` `code` `blockquote` `comment` `html` `hr`. Each is exactly
-`query(selector, matcher)`; `section` and `heading` also take `{ depth }`.
+A `string` matches exactly, a `RegExp` honors its own flags, and a function is called as a predicate over the node's text.
+
+These convenience selector methods accept a matcher:
+
+- `section`
+- `heading`
+- `paragraph`
+- `table`
+- `list`
+- `item`
+- `code`
+- `blockquote`
+- `comment`
+- `html`
+
+Each is equivalent to `query(selector, matcher)`. The `hr()` convenience method takes no matcher. `section` and `heading` also accept `{ depth }`:
 
-## Reading
+```js
+mdq(doc).section('Install', { depth: 2 });
+mdq(doc).heading(/^summary/i, { depth: 3 });
+```
+
+## Reading with the JavaScript API
 
 | Method | Returns |
 | --- | --- |
-| `text()` | raw markdown of every match, joined |
-| `nodes()` | `{ type, depth, text }` per match |
-| `rows()` | table rows as objects, keyed by header |
-| `entries()` | `Key: value` lines of a block, keys lowercased |
-| `count()` / `exists()` | how many matched / whether any did |
-| `first()` / `last()` / `at(n)` / `slice(from, to)` | narrow the selection |
-| `each()` | one single-match query per match |
-| `preceding()` / `following()` | everything before the first / after the last match |
+| `text()` | Raw Markdown from every match, joined together |
+| `nodes()` | One `{ type, depth, text }` object per match |
+| `rows()` | Table rows as objects keyed by table header |
+| `entries()` | `Key: value` lines from a block, with lowercase keys |
+| `count()` / `exists()` | The number of matches / whether any match exists |
+| `first()` / `last()` / `at(n)` / `slice(from, to)` | A narrowed selection |
+| `each()` | One single-match `MarkdownQuery` per match |
+| `preceding()` / `following()` | Everything before the first / after the last match |
 
-## Writing
+## Writing with the JavaScript API
 
-Every one returns a `MarkdownQuery` over the edited document.
+Every write returns a new `MarkdownQuery` over the complete edited document.
 
 | Method | Effect |
 | --- | --- |
-| `replace(md)` | replace each match |
-| `replaceEach(fn)` | replace each match with `fn(selection, index)` |
-| `remove()` | delete each match, and its blank line |
-| `insertBefore(md)` / `insertAfter(md)` | add a sibling block |
-| `prepend(md)` / `append(md)` | add a block inside a section or list |
-| `addRow(obj)` | append a table row, re-aligning the columns |
-| `addItem(text)` | append a list item, copying the existing marker |
-| `setEntry(key, value)` | set a `Key: value` line; `null` deletes it |
-
-`prepend` and `append` need a section or list; on any other block they raise
-`MdqOperationError`. Anything that takes markdown also takes a `MarkdownQuery`. Writes
-never leave zero blank lines between blocks, and never more than one — including inside
-fenced code blocks, which are left exactly as they are.
+| `replace(md)` | Replace every match |
+| `replaceEach(fn)` | Replace each match with `fn(selection, index)` |
+| `remove()` | Delete every match and its blank line |
+| `insertBefore(md)` / `insertAfter(md)` | Add a sibling block |
+| `prepend(md)` / `append(md)` | Add a block inside a section or list |
+| `addRow(obj)` | Append a table row and realign the columns |
+| `addItem(text)` | Append a list item using the existing list marker |
+| `setEntry(key, value)` | Set a `Key: value` line; pass `null` to delete it |
+| `setFrontmatter(key, value)` | Set a YAML frontmatter value |
+
+`prepend` and `append` require a section or list. Using either method on another block raises `MdqOperationError`.
+
+Any method that accepts Markdown also accepts another `MarkdownQuery`. Writes normalize spacing to exactly one blank line between blocks. Content inside fenced code blocks is preserved exactly.
 
 ## Frontmatter
 
-A leading `---` block is parsed as YAML, kept out of the token index, and exposed as data.
-Without this, `marked` reads `url: /login` as a setext heading.
+A leading `---` block is parsed as YAML, excluded from the token index, and exposed as data. This prevents `marked` from interpreting a line such as `url: /login` as a setext heading.
 
 ```js
 const doc = mdq(page);
-doc.frontmatter();                   // { url: '/login', wait: 1000, tags: ['auth'] }
-doc.query('h2').count();             // 0 — the --- block is not a heading
-doc.setFrontmatter('wait', 2000);    // comments and formatting survive
+
+doc.frontmatter();                // { url: '/login', wait: 1000, tags: ['auth'] }
+doc.query('h2').count();          // 0 — the --- block is not a heading
+
+const updated = doc
+  .setFrontmatter('wait', 2000)   // comments and formatting survive
+  .toString();
 ```
 
-## Prior art
+From the CLI:
+
+```bash
+npx mdq-cli --frontmatter page.md
+```
+
+## Implementation
+
+Under the hood, mdq uses `marked` to parse Markdown into a block-token AST before it queries or edits anything. Headings, paragraphs, tables, lists, list items, fenced code blocks, blockquotes, HTML, and thematic breaks all come from that parsed structure.
+
+### Processing model
 
-The selector grammar here is **bespoke**. It is not a standard, and there is no upstream
-parser for it — element names and descendant-by-space come from CSS, `[2:5]` slices from
-Python, and a tolerated leading `.` from jq.
+1. A leading YAML frontmatter block is separated from the Markdown body.
+2. `marked.lexer()` parses the body into block tokens, including nested list items and GFM table data.
+3. mdq indexes each token with its range in the original source.
+4. The selector parser converts the query into validated selector segments.
+5. The evaluator matches those segments against parsed tokens. It derives sections from heading depth and descendant scope from the selected token ranges.
+6. Edits splice only the selected source ranges. Untouched text remains unchanged, and the result is parsed again into a fresh `MarkdownQuery`.
 
-The established alternative is the **unified/remark** stack: parse to
-[mdast](https://github.com/syntax-tree/mdast), then select with
-[`unist-util-select`](https://github.com/syntax-tree/unist-util-select), which implements
-real CSS selectors on top of `css-selector-parser`. If you want a standards-based tool,
-use that.
+This model provides consistent queries and targeted edits while preserving content outside the selection.
 
-mdq exists because three things do not fall out of that stack:
+### Selector grammar
 
-- **Sections.** mdast is flat: a heading and the blocks beneath it are siblings, so the CSS
-  descendant combinator cannot express "this heading and everything under it until the next
-  heading of the same depth". [`remark-sectionize`](https://github.com/jake-low/remark-sectionize)
-  adds the nesting, but its synthetic `section` nodes carry no `position`, so their source
-  range has to be derived from their children before anything can be edited in place.
-- **Editing by byte range.** mdq records each block's offset in the original source and
-  splices text, so anything it does not touch stays byte-identical. mdast nodes do carry
-  offsets, so this is achievable there too — it is a thing to build, not a thing you get.
-- **Text and pattern matching.** mdast headings have no flat text field (the text is a child
-  node), CSS dropped `:contains()`, and `unist-util-select` parses the attribute `i` flag
-  but does not apply it — so `/^summary/i` has no selector form at all.
+The selector language has a small, explicit grammar:
 
-GFM tables are not in core remark either; they need `remark-gfm`.
+```text
+query     := segment (whitespace segment)*
+segment   := ["." ] name [matcher] position*
+name      := section | section1..section6
+           | heading | h1..h6
+           | paragraph | table | list | item | code
+           | blockquote | hr | html | comment
+matcher   := "(" ["!"] (quoted | "~" quoted | regex) ")"
+quoted    := '"' text '"'
+regex     := "/" pattern "/" flags
+position  := "[" integer "]"
+           | "[" [integer] ":" [integer] "]"
+```
+
+Whitespace between segments means “select inside the previous match.” A leading `.` is accepted as optional syntax. Indexes may be negative, and slices use `from:to` bounds. The complete selector must match this grammar: unknown names and unexpected characters raise `MdqSelectorError` with the failing character position.
+
+Markdown structure is not parsed with regular expressions. Regex is limited to selector tokenization, explicit `/pattern/flags` matchers, and small local formatting operations.
+
+### Libraries
+
+| Library | Purpose |
+| --- | --- |
+| [`marked`](https://marked.js.org/) | Parse Markdown into block tokens and provide GFM table and nested-list structure |
+| [`yaml`](https://eemeli.org/yaml/) | Parse and update YAML frontmatter through a document model that preserves comments and formatting |
+| [`commander`](https://github.com/tj/commander.js) | Parse CLI arguments and options, and generate command help |
 
+File input and in-place writes use Node.js built-in filesystem APIs.
 
-## Limitations
+## License
 
-- **Block-level comments only.** A comment inside a paragraph (`text <!-- x --> more`) is
-  part of that paragraph's token and is not reachable as a `comment`.
-- **No row or item selectors.** `addRow` and `addItem` append; there is no `removeRow`,
-  because there is nothing to select.
-- **YAML frontmatter only.** TOML (`+++`) and JSON blocks are skipped from the token index
-  but not parsed.
+MIT

package/bin/mdq.js

@@ -3,35 +3,6 @@
 // src/utils/mdq/cli.ts
 import { readFileSync, writeFileSync } from "node:fs";
 import { Command } from "commander";
-// src/utils/mdq/package.json
-var package_default = {
-  name: "mdq-cli",
-  version: "0.1.1",
-  description: "Query and edit markdown with a selector language - jq, for markdown",
-  license: "MIT",
-  type: "module",
-  main: "./index.js",
-  types: "./types/query.d.ts",
-  exports: {
-    ".": {
-      types: "./types/query.d.ts",
-      import: "./index.js"
-    }
-  },
-  bin: {
-    mdq: "./bin/mdq.js"
-  },
-  files: ["index.js", "types/", "bin/", "README.md"],
-  engines: {
-    node: ">=18"
-  },
-  keywords: ["markdown", "query", "selector", "cli", "jq", "frontmatter", "marked", "edit"],
-  repository: {
-    type: "git",
-    url: "https://github.com/testomatio/explorbot",
-    directory: "src/utils/mdq"
-  }
-};
 
 // src/utils/mdq/query.ts
 import { marked } from "marked";
@@ -662,19 +633,13 @@ var SEGMENT = /(\s*\.?)([A-Za-z]\w*)(?:\((!?)(~?)(?:"((?:[^"\\]|\\.)*)"|\/((?:[^
 // src/utils/mdq/cli.ts
 var EDIT_FLAGS = ["remove", "replace", "insertBefore", "insertAfter", "prepend", "append", "addRow", "addItem", "set"];
 async function runMdq(argv, readStdin) {
-  let printed = "";
   const program = new Command;
-  program.name("mdq").description("query and edit markdown").version(package_default.version, "-v, --version").argument("[selector]", "markdown selector").argument("[file]", "file to read; stdin when omitted").option("-j, --json", "output rows as JSON").option("-c, --count", "print the number of matches").option("-t, --text", "print unwrapped text").option("--frontmatter", "print frontmatter as JSON").option("-i, --in-place", "write the result back to the file").option("--remove", "delete matched blocks").option("--replace <markdown>", "replace matched blocks").option("--insert-before <markdown>", "insert before each match").option("--insert-after <markdown>", "insert after each match").option("--prepend <markdown>", "insert at the start of each match").option("--append <markdown>", "insert at the end of each match").option("--add-row <json>", "append a table row").option("--add-item <text>", "append a list item").option("--set <key=value>", "set an entry; omit the value to delete it").exitOverride().configureOutput({
-    writeOut: (text) => {
-      printed += text;
-    },
-    writeErr: () => {}
-  });
+  program.name("mdq-cli").description("query and edit markdown").argument("[selector]", "markdown selector").argument("[file]", "file to read; stdin when omitted").option("-j, --json", "output rows as JSON").option("-c, --count", "print the number of matches").option("-t, --text", "print unwrapped text").option("--frontmatter", "print frontmatter as JSON").option("-i, --in-place", "write the result back to the file").option("--remove", "delete matched blocks").option("--replace <markdown>", "replace matched blocks").option("--insert-before <markdown>", "insert before each match").option("--insert-after <markdown>", "insert after each match").option("--prepend <markdown>", "insert at the start of each match").option("--append <markdown>", "insert at the end of each match").option("--add-row <json>", "append a table row").option("--add-item <text>", "append a list item").option("--set <key=value>", "set an entry; omit the value to delete it").exitOverride().configureOutput({ writeOut: () => {}, writeErr: () => {} });
   try {
     program.parse(argv, { from: "user" });
   } catch (error) {
-    if (printed)
-      return { output: printed, code: 0 };
+    if (error.code === "commander.helpDisplayed")
+      return { output: program.helpInformation(), code: 0 };
     return { output: String(error.message), code: 2 };
   }
   const options = program.opts();

package/index.js

@@ -624,12 +624,12 @@ var SELECTOR_NAMES = new Set(["section", "heading", "paragraph", "table", "list"
 var TOKEN_ALIASES = { item: "list_item" };
 var SEGMENT = /(\s*\.?)([A-Za-z]\w*)(?:\((!?)(~?)(?:"((?:[^"\\]|\\.)*)"|\/((?:[^/\\]|\\.)*)\/([a-z]*))\))?((?:\[[^\]]*\])*)\s*/y;
 export {
-  parseQuery,
-  mdq,
-  buildTokenIndex,
-  MdqSelectorError,
-  MdqOperationError,
-  MdqError,
+  MarkdownEditor,
   MarkdownQuery,
-  MarkdownEditor
+  MdqError,
+  MdqOperationError,
+  MdqSelectorError,
+  buildTokenIndex,
+  mdq,
+  parseQuery
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mdq-cli",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Query and edit markdown with a selector language - jq, for markdown",
   "license": "MIT",
   "type": "module",
@@ -13,7 +13,7 @@
     }
   },
   "bin": {
-    "mdq": "./bin/mdq.js"
+    "mdq-cli": "./bin/mdq.js"
   },
   "files": [
     "index.js",