explorbot 0.4.9 → 0.5.0

package/src/utils/mdq/cli.ts

@@ -0,0 +1,118 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { Command } from 'commander';
+import { type MarkdownQuery, MdqError, mdq } from './query.ts';
+
+const EDIT_FLAGS = ['remove', 'replace', 'insertBefore', 'insertAfter', 'prepend', 'append', 'addRow', 'addItem', 'set'] as const;
+
+export async function runMdq(argv: string[], readStdin: StdinReader): Promise<CliResult> {
+  const program = new Command();
+  program
+    .name('mdq')
+    .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) {
+    return { output: String((error as Error).message), code: 2 };
+  }
+
+  const options = program.opts();
+  let [selector, file] = program.args;
+  if (options.frontmatter && selector && !file) {
+    file = selector;
+    selector = '';
+  }
+
+  let source = '';
+  if (!file) source = await readStdin();
+  if (file) {
+    try {
+      source = readFileSync(file, 'utf8');
+    } catch {
+      return { output: `Cannot read ${file}`, code: 2 };
+    }
+  }
+
+  try {
+    return await apply(mdq(source), selector, options, file);
+  } catch (error) {
+    if (error instanceof MdqError) return { output: error.message, code: 2 };
+    throw error;
+  }
+}
+
+async function apply(doc: MarkdownQuery, selector: string, options: Record<string, any>, file?: string): Promise<CliResult> {
+  if (options.frontmatter) return { output: `${JSON.stringify(doc.frontmatter(), null, 2)}\n`, code: 0 };
+  if (!selector) return { output: 'A selector is required', code: 2 };
+
+  const chosen = EDIT_FLAGS.filter((flag) => options[flag] !== undefined);
+  if (chosen.length > 1) return { output: 'Only one edit at a time', code: 2 };
+
+  const selection = doc.query(selector);
+  if (chosen.length === 0) return read(selection, options);
+
+  if (!selection.exists()) return finish(String(doc), 1, options, file);
+  return finish(String(edit(selection, chosen[0], options)), 0, options, file);
+}
+
+function read(selection: MarkdownQuery, options: Record<string, any>): CliResult {
+  let code = 1;
+  if (selection.exists()) code = 0;
+  if (options.count) return { output: `${selection.count()}\n`, code: 0 };
+  if (options.json) return { output: `${JSON.stringify(selection.rows(), null, 2)}\n`, code };
+  if (options.text)
+    return {
+      output: selection
+        .nodes()
+        .map((node) => node.text)
+        .join('\n\n'),
+      code,
+    };
+  return { output: selection.text(), code };
+}
+
+function edit(selection: MarkdownQuery, flag: string, options: Record<string, any>): MarkdownQuery {
+  if (flag === 'remove') return selection.remove();
+  if (flag === 'replace') return selection.replace(options.replace);
+  if (flag === 'insertBefore') return selection.insertBefore(options.insertBefore);
+  if (flag === 'insertAfter') return selection.insertAfter(options.insertAfter);
+  if (flag === 'prepend') return selection.prepend(options.prepend);
+  if (flag === 'append') return selection.append(options.append);
+  if (flag === 'addItem') return selection.addItem(options.addItem);
+  if (flag === 'addRow') return selection.addRow(JSON.parse(options.addRow));
+  const separator = options.set.indexOf('=');
+  if (separator < 0) return selection.setEntry(options.set, null);
+  return selection.setEntry(options.set.slice(0, separator), options.set.slice(separator + 1) || null);
+}
+
+function finish(output: string, code: number, options: Record<string, any>, file?: string): CliResult {
+  if (!options.inPlace) return { output, code };
+  if (!file) return { output: '--in-place needs a file', code: 2 };
+  writeFileSync(file, output);
+  return { output: '', code };
+}
+
+export type StdinReader = () => Promise<string>;
+
+export interface CliResult {
+  output: string;
+  code: number;
+}

package/src/utils/mdq/edit.ts

@@ -0,0 +1,158 @@
+import YAML from 'yaml';
+import type { MatchedRange } from './query.ts';
+
+export class MarkdownEditor {
+  private source: string;
+
+  constructor(source: string) {
+    this.source = source;
+  }
+
+  static splitFrontmatter(source: string): FrontmatterSplit {
+    if (!source.startsWith('---')) return { raw: '', body: source, offset: 0 };
+    const match = source.match(/^---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)/);
+    if (!match) return { raw: '', body: source, offset: 0 };
+    return { raw: match[1], body: source.slice(match[0].length), offset: match[0].length };
+  }
+
+  static blockEnd(range: MatchedRange): number {
+    if (range.trailing) return range.trailing.start + range.trailing.length;
+    return range.start + range.length;
+  }
+
+  static table(headers: string[], rows: string[][], align: (string | null)[]): string {
+    const widths = headers.map((header, index) => Math.max(header.length, 3, ...rows.map((row) => (row[index] || '').length)));
+    const line = (cells: string[]) => `| ${cells.map((cell, index) => (cell || '').padEnd(widths[index])).join(' | ')} |`;
+    const divider = `| ${widths.map((width, index) => MarkdownEditor.dashes(align[index], width)).join(' | ')} |`;
+    return `${[line(headers), divider, ...rows.map(line)].join('\n')}\n`;
+  }
+
+  static item(listRaw: string, text: string): string {
+    const lines = listRaw.split('\n').filter((line) => line.trim());
+    const last = lines[lines.length - 1] || '- x';
+    const ordered = last.match(/^(\s*)(\d+)([.)])\s/);
+    if (ordered) return `${ordered[1]}${Number.parseInt(ordered[2], 10) + 1}${ordered[3]} ${text}`;
+    const bullet = last.match(/^(\s*)([-*+])\s/);
+    if (!bullet) return `- ${text}`;
+    return `${bullet[1]}${bullet[2]} ${text}`;
+  }
+
+  static entries(text: string, key: string, value: string | null, isBlockquote: boolean): string {
+    const lines = text
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean);
+
+    const index = lines.findIndex((line) => MarkdownEditor.entryKey(line) === key.toLowerCase());
+    if (index < 0 && value) lines.push(`${key}: ${value}`);
+    if (index >= 0 && value) lines[index] = `${key}: ${value}`;
+    if (index >= 0 && !value) lines.splice(index, 1);
+
+    if (!isBlockquote) return lines.join('\n');
+    return lines.map((line) => `> ${line}`).join('\n');
+  }
+
+  remove(ranges: MatchedRange[]): string {
+    const ordered = this.dedupe(ranges);
+    let result = this.source;
+
+    for (let i = ordered.length - 1; i >= 0; i--) {
+      const range = ordered[i];
+      const head = result.slice(0, range.start);
+      const tail = result.slice(MarkdownEditor.blockEnd(range));
+      if (tail) {
+        result = head + tail;
+        continue;
+      }
+      if (!head) {
+        result = '';
+        continue;
+      }
+      result = `${head.trimEnd()}\n`;
+    }
+
+    return result;
+  }
+
+  replace(ranges: MatchedRange[], render: (range: MatchedRange, index: number) => string): string {
+    const ordered = this.dedupe(ranges);
+    const rendered = ordered.map(render);
+    let result = this.source;
+
+    for (let i = ordered.length - 1; i >= 0; i--) {
+      const range = ordered[i];
+      result = result.slice(0, range.start) + rendered[i] + result.slice(range.start + range.length);
+    }
+
+    return result;
+  }
+
+  insert(offsets: number[], markdown: string): string {
+    const ordered = [...offsets].sort((a, b) => a - b);
+    let result = this.source;
+    for (let i = ordered.length - 1; i >= 0; i--) {
+      result = MarkdownEditor.spliceIn(result, ordered[i], markdown);
+    }
+    return result;
+  }
+
+  frontmatter(): Record<string, unknown> {
+    const { raw } = MarkdownEditor.splitFrontmatter(this.source);
+    if (!raw) return {};
+    return (YAML.parseDocument(raw).toJS() as Record<string, unknown>) || {};
+  }
+
+  setFrontmatter(key: string, value: unknown): string {
+    const { raw, body, offset } = MarkdownEditor.splitFrontmatter(this.source);
+    let document = new YAML.Document({});
+    if (raw) document = YAML.parseDocument(raw);
+    if (value === null) document.delete(key);
+    if (value !== null) document.set(key, value);
+
+    const rendered = document.toString().trimEnd();
+    if (!offset) return `---\n${rendered}\n---\n\n${this.source}`;
+    return `---\n${rendered}\n---\n${body}`;
+  }
+
+  private static spliceIn(source: string, offset: number, markdown: string): string {
+    const block = `${markdown.trimEnd()}\n`;
+    const before = source.slice(0, offset).replace(/\n+$/, '');
+    const after = source.slice(offset).replace(/^\n+/, '');
+    if (!before) return `${block}\n${after}`;
+    if (!after) return `${before}\n\n${block}`;
+    return `${before}\n\n${block}\n${after}`;
+  }
+
+  private static dashes(alignment: string | null, width: number): string {
+    if (alignment === 'center') return `:${'-'.repeat(Math.max(width - 2, 1))}:`;
+    if (alignment === 'left') return `:${'-'.repeat(Math.max(width - 1, 1))}`;
+    if (alignment === 'right') return `${'-'.repeat(Math.max(width - 1, 1))}:`;
+    return '-'.repeat(width);
+  }
+
+  private static entryKey(line: string): string | null {
+    const separator = line.indexOf(':');
+    if (separator < 1) return null;
+    return line.slice(0, separator).trim().toLowerCase();
+  }
+
+  private dedupe(ranges: MatchedRange[]): MatchedRange[] {
+    const sorted = [...ranges].sort((a, b) => a.start - b.start);
+    const kept: MatchedRange[] = [];
+    let lastEnd = -1;
+
+    for (const range of sorted) {
+      if (range.start < lastEnd) continue;
+      kept.push(range);
+      lastEnd = range.start + range.length;
+    }
+
+    return kept;
+  }
+}
+
+export interface FrontmatterSplit {
+  raw: string;
+  body: string;
+  offset: number;
+}