lilmd 0.1.0

package/dist/mdq.js

@@ -0,0 +1,735 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/cli.ts
+import { parseArgs } from "node:util";
+import { readFileSync } from "node:fs";
+
+// src/scan.ts
+function scan(src) {
+  const out = [];
+  const len = src.length;
+  let i = 0;
+  let lineNo = 0;
+  let inFence = false;
+  let fenceChar = 0;
+  let fenceLen = 0;
+  while (i <= len) {
+    const start = i;
+    while (i < len && src.charCodeAt(i) !== 10)
+      i++;
+    let line = src.slice(start, i);
+    if (line.length > 0 && line.charCodeAt(line.length - 1) === 13) {
+      line = line.slice(0, line.length - 1);
+    }
+    lineNo++;
+    const fence = matchFence(line);
+    if (fence) {
+      if (!inFence) {
+        inFence = true;
+        fenceChar = fence.char;
+        fenceLen = fence.len;
+      } else if (fence.char === fenceChar && fence.len >= fenceLen) {
+        inFence = false;
+      }
+    } else if (!inFence) {
+      const h = matchHeading(line, lineNo);
+      if (h)
+        out.push(h);
+    }
+    if (i >= len)
+      break;
+    i++;
+  }
+  return out;
+}
+function matchFence(line) {
+  let p = 0;
+  while (p < 3 && line.charCodeAt(p) === 32)
+    p++;
+  const ch = line.charCodeAt(p);
+  if (ch !== 96 && ch !== 126)
+    return null;
+  let run = 0;
+  while (line.charCodeAt(p + run) === ch)
+    run++;
+  if (run < 3)
+    return null;
+  return { char: ch, len: run };
+}
+function matchHeading(line, lineNo) {
+  let p = 0;
+  while (p < 3 && line.charCodeAt(p) === 32)
+    p++;
+  if (line.charCodeAt(p) !== 35)
+    return null;
+  let hashes = 0;
+  while (line.charCodeAt(p + hashes) === 35)
+    hashes++;
+  if (hashes < 1 || hashes > 6)
+    return null;
+  const after = p + hashes;
+  const afterCh = line.charCodeAt(after);
+  if (after < line.length && afterCh !== 32 && afterCh !== 9) {
+    return null;
+  }
+  let contentStart = after;
+  while (contentStart < line.length && (line.charCodeAt(contentStart) === 32 || line.charCodeAt(contentStart) === 9)) {
+    contentStart++;
+  }
+  let end = line.length;
+  while (end > contentStart && (line.charCodeAt(end - 1) === 32 || line.charCodeAt(end - 1) === 9)) {
+    end--;
+  }
+  let closing = end;
+  while (closing > contentStart && line.charCodeAt(closing - 1) === 35)
+    closing--;
+  if (closing < end && (closing === contentStart || line.charCodeAt(closing - 1) === 32 || line.charCodeAt(closing - 1) === 9)) {
+    end = closing;
+    while (end > contentStart && (line.charCodeAt(end - 1) === 32 || line.charCodeAt(end - 1) === 9)) {
+      end--;
+    }
+  }
+  const title = line.slice(contentStart, end);
+  return { level: hashes, title, line: lineNo };
+}
+
+// src/sections.ts
+function buildSections(headings, totalLines) {
+  const out = [];
+  const stack = [];
+  for (const h of headings) {
+    while (stack.length > 0 && stack[stack.length - 1].level >= h.level) {
+      const closing = stack.pop();
+      closing.line_end = h.line - 1;
+    }
+    const parent = stack.length > 0 ? stack[stack.length - 1] : null;
+    const sec = {
+      level: h.level,
+      title: h.title,
+      line_start: h.line,
+      line_end: totalLines,
+      parent
+    };
+    out.push(sec);
+    stack.push(sec);
+  }
+  return out;
+}
+function pathOf(sec) {
+  const path = [];
+  let cur = sec.parent;
+  while (cur) {
+    path.push(cur.title);
+    cur = cur.parent;
+  }
+  return path.reverse();
+}
+function countLines(src) {
+  if (src.length === 0)
+    return 0;
+  let n = 1;
+  for (let i = 0;i < src.length; i++) {
+    if (src.charCodeAt(i) === 10)
+      n++;
+  }
+  if (src.charCodeAt(src.length - 1) === 10)
+    n--;
+  return n;
+}
+
+// src/select.ts
+function parseSelector(input) {
+  const trimmed = input.trim();
+  if (trimmed.length === 0)
+    return [];
+  const rawSegments = [];
+  const ops = ["descendant"];
+  let cur = "";
+  let i = 0;
+  let inRegex = false;
+  let atSegmentStart = true;
+  while (i < trimmed.length) {
+    const ch = trimmed[i];
+    if (ch === "/" && (atSegmentStart || inRegex)) {
+      inRegex = !inRegex;
+      cur += ch;
+      atSegmentStart = false;
+      i++;
+      continue;
+    }
+    if (!inRegex && ch === ">") {
+      rawSegments.push(cur.trim());
+      cur = "";
+      atSegmentStart = true;
+      if (trimmed[i + 1] === ">") {
+        ops.push("child");
+        i += 2;
+      } else {
+        ops.push("descendant");
+        i += 1;
+      }
+      continue;
+    }
+    cur += ch;
+    if (ch !== " " && ch !== "\t")
+      atSegmentStart = false;
+    i++;
+  }
+  rawSegments.push(cur.trim());
+  return rawSegments.map((s, idx) => parseSegment(s, ops[idx] ?? "descendant"));
+}
+function parseSegment(raw, op) {
+  let s = raw;
+  let level = null;
+  const levelMatch = /^(#{1,6})(?!#)\s*(.*)$/.exec(s);
+  if (levelMatch) {
+    level = levelMatch[1].length;
+    s = levelMatch[2] ?? "";
+  }
+  const regexMatch = /^\/(.+)\/([gimsuy]*)$/.exec(s);
+  if (regexMatch) {
+    const pattern = regexMatch[1];
+    const flags = regexMatch[2] || "i";
+    return {
+      op,
+      level,
+      kind: "regex",
+      value: pattern,
+      regex: new RegExp(pattern, flags)
+    };
+  }
+  if (s.startsWith("=")) {
+    return { op, level, kind: "exact", value: s.slice(1).trim() };
+  }
+  return { op, level, kind: "fuzzy", value: s.trim() };
+}
+function match(sections, selector) {
+  if (selector.length === 0)
+    return [];
+  const out = [];
+  for (const sec of sections) {
+    if (matches(sec, selector))
+      out.push(sec);
+  }
+  return out;
+}
+function matches(sec, segs) {
+  const last = segs[segs.length - 1];
+  if (!last || !segmentMatchesSection(last, sec))
+    return false;
+  let cursor = sec.parent;
+  for (let i = segs.length - 2;i >= 0; i--) {
+    const op = segs[i + 1].op;
+    const seg = segs[i];
+    if (op === "child") {
+      if (!cursor || !segmentMatchesSection(seg, cursor))
+        return false;
+      cursor = cursor.parent;
+    } else {
+      let found = null;
+      while (cursor) {
+        if (segmentMatchesSection(seg, cursor)) {
+          found = cursor;
+          break;
+        }
+        cursor = cursor.parent;
+      }
+      if (!found)
+        return false;
+      cursor = found.parent;
+    }
+  }
+  return true;
+}
+function segmentMatchesSection(seg, sec) {
+  if (seg.level !== null && seg.level !== sec.level)
+    return false;
+  const title = sec.title;
+  switch (seg.kind) {
+    case "exact":
+      return title.toLowerCase() === seg.value.toLowerCase();
+    case "regex":
+      return seg.regex.test(title);
+    case "fuzzy":
+      return title.toLowerCase().includes(seg.value.toLowerCase());
+  }
+}
+
+// src/render.ts
+function renderToc(file, src, sections, opts) {
+  const totalLines = countLines(src);
+  const headerCount = sections.length;
+  const headerRange = totalLines === 0 ? "L0" : `L1-${totalLines}`;
+  const plural = headerCount === 1 ? "heading" : "headings";
+  const out = [];
+  out.push(`${file}  ${headerRange}  ${headerCount} ${plural}`);
+  for (const sec of sections) {
+    if (opts.depth != null && sec.level > opts.depth)
+      continue;
+    const indent = opts.flat ? "" : "  ".repeat(Math.max(0, sec.level - 1));
+    const hashes = "#".repeat(sec.level);
+    const range = `L${sec.line_start}-${sec.line_end}`;
+    out.push(`${indent}${hashes} ${sec.title}  ${range}`);
+  }
+  return out.join(`
+`);
+}
+function renderSection(file, srcLines, sec, opts) {
+  const start = sec.line_start;
+  let end = sec.line_end;
+  if (opts.bodyOnly && opts.allSections) {
+    const firstChild = findFirstChild(sec, opts.allSections);
+    if (firstChild)
+      end = firstChild.line_start - 1;
+  }
+  if (opts.noBody) {
+    end = start;
+  }
+  const clampedEnd = Math.min(end, srcLines.length);
+  let body = srcLines.slice(start - 1, clampedEnd).join(`
+`);
+  if (opts.maxLines != null && opts.maxLines > 0) {
+    body = truncateBody(body, opts.maxLines);
+  }
+  if (opts.pretty) {
+    body = opts.pretty(body);
+  }
+  if (opts.raw)
+    return body;
+  const hashes = "#".repeat(sec.level);
+  const header = `── ${file}  L${start}-${end}  ${hashes} ${sec.title} ${"─".repeat(8)}`;
+  const footer = `── end ${"─".repeat(40)}`;
+  return `${header}
+${body}
+${footer}`;
+}
+function truncateBody(body, maxLines) {
+  if (maxLines <= 0)
+    return body;
+  const lines = body.split(`
+`);
+  if (lines.length <= maxLines)
+    return body;
+  const kept = lines.slice(0, maxLines).join(`
+`);
+  const remaining = lines.length - maxLines;
+  return `${kept}
+
+… ${remaining} more lines (use --max-lines=0 for full)`;
+}
+function findFirstChild(sec, all) {
+  for (const candidate of all) {
+    if (candidate.parent === sec)
+      return candidate;
+  }
+  return null;
+}
+
+// src/pretty.ts
+var formatterPromise = null;
+function loadPrettyFormatter() {
+  return formatterPromise ??= buildFormatter();
+}
+async function buildFormatter() {
+  const [{ marked }, { markedTerminal }] = await Promise.all([
+    import("marked"),
+    import("marked-terminal")
+  ]);
+  marked.use(markedTerminal({
+    reflowText: false,
+    tab: 2,
+    hr: "─"
+  }));
+  return (md) => {
+    const originalError = console.error;
+    console.error = (...args) => {
+      if (typeof args[0] === "string" && /Could not find the language/i.test(args[0]))
+        return;
+      originalError.apply(console, args);
+    };
+    let rendered;
+    try {
+      rendered = marked.parse(md);
+    } finally {
+      console.error = originalError;
+    }
+    if (typeof rendered !== "string") {
+      throw new Error("mdq: pretty renderer returned a Promise unexpectedly");
+    }
+    return rendered.replace(/\n+$/, "");
+  };
+}
+
+// src/cli.ts
+var HELP = `mdq — CLI for working with large Markdown files
+
+Usage:
+  mdq                              show this help
+  mdq <file>                       print table of contents
+  mdq <file> <selector>            alias for 'mdq read'
+  mdq read <file> <selector>       print sections matching selector
+  mdq ls   <file> <selector>       list direct child headings
+  mdq grep <file> <pattern>        regex-search section bodies
+
+Selector grammar:
+  Install                   fuzzy, case-insensitive substring
+  =Install                  exact, case-insensitive equality
+  /^inst/i                  regex (JS syntax); flags default to 'i'
+  ##Install                 level filter (1..6 '#'s)
+  Guide > Install           descendant, any depth under 'Guide'
+  Guide >> Install          direct child of 'Guide'
+
+Options:
+  --depth <n>               TOC: max heading depth to show (0 = none)
+  --flat                    TOC: flat list, no indentation
+  --max-results <n>         cap matches for read/ls (default 25)
+  --max-lines <n>           truncate long bodies (0 = unlimited)
+  --body-only               read: skip subsections
+  --no-body                 read: print headings only
+  --raw                     read: drop delimiter lines
+  --pretty                  read: render markdown with ANSI styling (for humans)
+  --json                    machine-readable JSON output
+
+Use '-' as <file> to read from stdin. Exit code is 1 when no matches.
+`;
+function ok(s) {
+  return { code: 0, stdout: s, stderr: "" };
+}
+function noMatch(s) {
+  return { code: 1, stdout: s, stderr: "" };
+}
+function err(s, code = 1) {
+  return { code, stdout: "", stderr: s };
+}
+var OPTIONS = {
+  depth: { type: "string" },
+  flat: { type: "boolean" },
+  "max-results": { type: "string" },
+  "max-lines": { type: "string" },
+  "body-only": { type: "boolean" },
+  "no-body": { type: "boolean" },
+  raw: { type: "boolean" },
+  pretty: { type: "boolean" },
+  json: { type: "boolean" },
+  help: { type: "boolean", short: "h" }
+};
+async function run(argv) {
+  let parsed;
+  try {
+    parsed = parseArgs({
+      args: argv,
+      options: OPTIONS,
+      allowPositionals: true,
+      strict: true
+    });
+  } catch (e) {
+    return err(`mdq: ${e.message}
+${HELP}`, 2);
+  }
+  const { values, positionals } = parsed;
+  if (values.help || positionals.length === 0) {
+    return ok(HELP);
+  }
+  const head = positionals[0];
+  if (head === "read" || head === "ls" || head === "grep" || head === "toc") {
+    return dispatch(head, positionals.slice(1), values);
+  }
+  if (positionals.length === 1)
+    return dispatch("toc", positionals, values);
+  return dispatch("read", positionals, values);
+}
+async function dispatch(cmd, rest, values) {
+  switch (cmd) {
+    case "toc":
+      return cmdToc(rest, values);
+    case "read":
+      return cmdRead(rest, values);
+    case "ls":
+      return cmdLs(rest, values);
+    case "grep":
+      return cmdGrep(rest, values);
+    default:
+      return err(`mdq: unknown command '${cmd}'
+${HELP}`, 2);
+  }
+}
+function loadFile(file) {
+  try {
+    const src = file === "-" ? readFileSync(0, "utf8") : readFileSync(file, "utf8");
+    return { src };
+  } catch (e) {
+    const msg = e.code === "ENOENT" ? `mdq: cannot open '${file}': not found
+` : `mdq: cannot open '${file}': ${e.message}
+`;
+    return err(msg, 2);
+  }
+}
+function parseIntOrNull(v) {
+  if (v == null)
+    return null;
+  const n = Number.parseInt(v, 10);
+  if (Number.isNaN(n) || String(n) !== v.trim())
+    return null;
+  return n;
+}
+function readFlag(v, name, fallback) {
+  const raw = v[name];
+  if (raw == null)
+    return { value: fallback };
+  const n = parseIntOrNull(raw);
+  if (n == null || n < 0) {
+    return err(`mdq: --${name} expects a non-negative integer, got '${raw}'
+`, 2);
+  }
+  return { value: n };
+}
+function cmdToc(rest, v) {
+  const file = rest[0];
+  if (file == null)
+    return err(`mdq toc: missing <file>
+`, 2);
+  const loaded = loadFile(file);
+  if ("code" in loaded)
+    return loaded;
+  const { src } = loaded;
+  const sections = buildSections(scan(src), countLines(src));
+  if (v.json) {
+    return ok(JSON.stringify({
+      file,
+      total_lines: countLines(src),
+      headings: sections.map(sectionToJSON)
+    }, null, 2));
+  }
+  const depth = readFlag(v, "depth", null);
+  if ("code" in depth)
+    return depth;
+  return ok(renderToc(file, src, sections, {
+    depth: depth.value ?? undefined,
+    flat: !!v.flat
+  }));
+}
+async function cmdRead(rest, v) {
+  const file = rest[0];
+  const selectorStr = rest[1];
+  if (file == null || selectorStr == null) {
+    return err(`mdq read: missing <file> or <selector>
+`, 2);
+  }
+  if (v.pretty && v.json) {
+    return err(`mdq read: --pretty cannot be combined with --json
+`, 2);
+  }
+  const loaded = loadFile(file);
+  if ("code" in loaded)
+    return loaded;
+  const { src } = loaded;
+  const sections = buildSections(scan(src), countLines(src));
+  const maxResults = readFlag(v, "max-results", 25);
+  if ("code" in maxResults)
+    return maxResults;
+  const maxLines = readFlag(v, "max-lines", 0);
+  if ("code" in maxLines)
+    return maxLines;
+  const selector = parseSelector(selectorStr);
+  const matches2 = match(sections, selector);
+  const srcLines = src.split(`
+`);
+  if (v.json) {
+    return emitReadJson(file, srcLines, sections, matches2, maxResults.value ?? 25, maxLines.value ?? 0, v);
+  }
+  if (matches2.length === 0)
+    return noMatch(`(no match)
+`);
+  let pretty;
+  if (v.pretty) {
+    try {
+      pretty = await loadPrettyFormatter();
+    } catch (e) {
+      return err(`mdq read: ${e.message}
+`, 2);
+    }
+  }
+  const cap = maxResults.value ?? 25;
+  const toPrint = matches2.slice(0, cap);
+  const out = [];
+  if (matches2.length > cap) {
+    out.push(`${matches2.length} matches, showing first ${cap}. Use --max-results=N to raise the cap.`);
+  }
+  for (const sec of toPrint) {
+    out.push(renderSection(file, srcLines, sec, {
+      bodyOnly: !!v["body-only"],
+      noBody: !!v["no-body"],
+      raw: !!v.raw,
+      maxLines: maxLines.value ?? 0,
+      allSections: sections,
+      pretty
+    }));
+  }
+  return ok(out.join(`
+`));
+}
+function emitReadJson(file, srcLines, all, matches2, maxResults, maxLines, v) {
+  const body = JSON.stringify({
+    file,
+    matches: matches2.slice(0, maxResults).map((s) => ({
+      ...sectionToJSON(s),
+      body: v["no-body"] ? "" : maybeTruncate(sliceBody(srcLines, s, all, !!v["body-only"]), maxLines)
+    })),
+    truncated: matches2.length > maxResults
+  }, null, 2);
+  return matches2.length === 0 ? { code: 1, stdout: body, stderr: "" } : ok(body);
+}
+function cmdLs(rest, v) {
+  const file = rest[0];
+  const selectorStr = rest[1];
+  if (file == null || selectorStr == null) {
+    return err(`mdq ls: missing <file> or <selector>
+`, 2);
+  }
+  const loaded = loadFile(file);
+  if ("code" in loaded)
+    return loaded;
+  const { src } = loaded;
+  const sections = buildSections(scan(src), countLines(src));
+  const maxResults = readFlag(v, "max-results", 25);
+  if ("code" in maxResults)
+    return maxResults;
+  const cap = maxResults.value ?? 25;
+  const selector = parseSelector(selectorStr);
+  const matches2 = match(sections, selector).slice(0, cap);
+  const childrenOf = new Map;
+  for (const sec of sections) {
+    if (sec.parent) {
+      const list = childrenOf.get(sec.parent);
+      if (list)
+        list.push(sec);
+      else
+        childrenOf.set(sec.parent, [sec]);
+    }
+  }
+  if (v.json) {
+    const results = matches2.map((parent) => ({
+      parent: sectionToJSON(parent),
+      children: (childrenOf.get(parent) ?? []).map(sectionToJSON)
+    }));
+    const body = JSON.stringify({ file, results }, null, 2);
+    return matches2.length === 0 ? { code: 1, stdout: body, stderr: "" } : ok(body);
+  }
+  if (matches2.length === 0)
+    return noMatch(`(no match)
+`);
+  const out = [];
+  for (const parent of matches2) {
+    const children = childrenOf.get(parent) ?? [];
+    out.push(`${"#".repeat(parent.level)} ${parent.title}  L${parent.line_start}-${parent.line_end}`);
+    if (children.length === 0) {
+      out.push("  (no children)");
+    } else {
+      for (const c of children) {
+        out.push(`  ${"#".repeat(c.level)} ${c.title}  L${c.line_start}-${c.line_end}`);
+      }
+    }
+  }
+  return ok(out.join(`
+`));
+}
+function cmdGrep(rest, v) {
+  const file = rest[0];
+  const pattern = rest[1];
+  if (file == null || pattern == null) {
+    return err(`mdq grep: missing <file> or <pattern>
+`, 2);
+  }
+  const loaded = loadFile(file);
+  if ("code" in loaded)
+    return loaded;
+  const { src } = loaded;
+  const sections = buildSections(scan(src), countLines(src));
+  let re;
+  try {
+    re = new RegExp(pattern);
+  } catch (e) {
+    return err(`mdq grep: invalid regex: ${e.message}
+`, 2);
+  }
+  const srcLines = src.split(`
+`);
+  const hits = [];
+  let secIdx = -1;
+  for (let lineNo = 1;lineNo <= srcLines.length; lineNo++) {
+    while (secIdx + 1 < sections.length && sections[secIdx + 1].line_start <= lineNo) {
+      secIdx++;
+    }
+    const line = srcLines[lineNo - 1];
+    if (re.test(line)) {
+      const section = secIdx >= 0 ? sections[secIdx] ?? null : null;
+      hits.push({ section, line: lineNo, text: line });
+    }
+  }
+  if (v.json) {
+    const body = JSON.stringify(hits.map((h) => ({
+      file,
+      line: h.line,
+      text: h.text,
+      section: h.section ? sectionToJSON(h.section) : null
+    })), null, 2);
+    return hits.length === 0 ? { code: 1, stdout: body, stderr: "" } : ok(body);
+  }
+  if (hits.length === 0)
+    return noMatch(`(no match)
+`);
+  const out = [];
+  let lastSection = undefined;
+  for (const hit of hits) {
+    if (hit.section !== lastSection) {
+      if (hit.section) {
+        const path = pathOf(hit.section).concat(hit.section.title).join(" > ");
+        out.push(`── ${path}  L${hit.section.line_start}-${hit.section.line_end}`);
+      } else {
+        out.push(`── ${file}  (no enclosing heading)`);
+      }
+      lastSection = hit.section;
+    }
+    out.push(`  L${hit.line}:  ${hit.text}`);
+  }
+  return ok(out.join(`
+`));
+}
+function sliceBody(srcLines, sec, all, bodyOnly) {
+  let end = sec.line_end;
+  if (bodyOnly) {
+    const firstChild = all.find((s) => s.parent === sec);
+    if (firstChild)
+      end = firstChild.line_start - 1;
+  }
+  return srcLines.slice(sec.line_start - 1, end).join(`
+`);
+}
+function maybeTruncate(body, maxLines) {
+  return maxLines > 0 ? truncateBody(body, maxLines) : body;
+}
+function sectionToJSON(sec) {
+  return {
+    level: sec.level,
+    title: sec.title,
+    line_start: sec.line_start,
+    line_end: sec.line_end,
+    path: pathOf(sec)
+  };
+}
+
+// bin/mdq.ts
+var result = await run(process.argv.slice(2));
+if (result.stdout) {
+  process.stdout.write(result.stdout.endsWith(`
+`) ? result.stdout : result.stdout + `
+`);
+}
+if (result.stderr)
+  process.stderr.write(result.stderr);
+process.exit(result.code);
+
+//# debugId=21A3DDC69C33B5A064756E2164756E21
+//# sourceMappingURL=mdq.js.map