draco-cli 0.0.0-stage → 3.0.2

package/src/tools/index.js

@@ -0,0 +1,152 @@
+'use strict';
+
+const { webFetch, webSearch } = require('./web-tools.js');
+
+const FS_TOOLS = [
+  {
+    type: 'function',
+    function: {
+      name: 'readFile',
+      description:
+        'Read a text file from the workspace into context. Large files are truncated.',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'Relative or absolute path inside the workspace.' },
+        },
+        required: ['path'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'writeFile',
+      description:
+        'Create or overwrite a file in the workspace. Parent directories are created automatically.',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'Relative or absolute path inside the workspace.' },
+          content: { type: 'string', description: 'Full file contents to write.' },
+        },
+        required: ['path', 'content'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'makeDirectory',
+      description: 'Create a directory (and any missing parents) inside the workspace.',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'Directory path to create.' },
+        },
+        required: ['path'],
+      },
+    },
+  },
+];
+
+const EXEC_TOOLS = [
+  {
+    type: 'function',
+    function: {
+      name: 'executeShell',
+      description:
+        'Run a shell command in the workspace via the OS default shell. Requires user confirmation unless approval mode allows it. 45s timeout.',
+      parameters: {
+        type: 'object',
+        properties: {
+          command: { type: 'string', description: 'The shell command line to run.' },
+          cwd: { type: 'string', description: 'Optional working directory inside the workspace.' },
+          shell: { type: 'string', description: 'Optional explicit shell binary override.' },
+        },
+        required: ['command'],
+      },
+    },
+  },
+];
+
+const WEB_TOOLS = [
+  {
+    type: 'function',
+    function: {
+      name: 'webFetch',
+      description:
+        'Fetch an http/https URL and return its content as cleaned plain text (or raw HTML with format="html"). Internal/private network targets are blocked.',
+      parameters: {
+        type: 'object',
+        properties: {
+          url: { type: 'string', description: 'The http(s) URL to fetch.' },
+          format: { type: 'string', enum: ['text', 'html'], description: 'Response format. Defaults to text.' },
+        },
+        required: ['url'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'webSearch',
+      description:
+        'Search the public web and return the top results as title/url/snippet triples.',
+      parameters: {
+        type: 'object',
+        properties: {
+          query: { type: 'string', description: 'Search query.' },
+        },
+        required: ['query'],
+      },
+    },
+  },
+];
+
+function buildToolDefs(mcpTools) {
+  const defs = [...FS_TOOLS, ...EXEC_TOOLS, ...WEB_TOOLS];
+  for (const tool of mcpTools || []) {
+    defs.push({
+      type: 'function',
+      function: {
+        name: tool.qualifiedName,
+        description:
+          (tool.description || `MCP tool from server "${tool.serverName}"`) +
+          ` [MCP server: ${tool.serverName}]`,
+        parameters: tool.inputSchema || { type: 'object', properties: {} },
+      },
+    });
+  }
+  return defs;
+}
+
+async function executeTool(name, args, ctx) {
+  try {
+    if (name.startsWith('mcp_')) {
+      if (!ctx.mcp) return 'Error: MCP is not available in this session.';
+      const text = await ctx.mcp.call(name, args);
+      return text || '(tool returned no output)';
+    }
+    switch (name) {
+      case 'readFile':
+        return require('./fs-tools.js').readFile(ctx.workspaceRoot, args.path);
+      case 'writeFile':
+        return await require('./fs-tools.js').writeFile(ctx.workspaceRoot, args.path, args.content, ctx);
+      case 'makeDirectory':
+        return await require('./fs-tools.js').makeDirectory(ctx.workspaceRoot, args.path, ctx);
+      case 'executeShell':
+        return await require('./shell-tool.js').executeShell(args, ctx);
+      case 'webFetch':
+        return await webFetch(args);
+      case 'webSearch':
+        return await webSearch(args, ctx.cfg);
+      default:
+        return `Error: unknown tool "${name}".`;
+    }
+  } catch (e) {
+    return `Error: ${e.message || e}`;
+  }
+}
+
+module.exports = { buildToolDefs, executeTool };

package/src/tools/sandbox.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const path = require('path');
+
+function sandboxPath(workspaceRoot, p) {
+  if (typeof p !== 'string' || !p.trim()) {
+    throw new Error('A non-empty "path" is required.');
+  }
+  const rootAbs = path.resolve(workspaceRoot);
+  const abs = path.resolve(rootAbs, p);
+  const rel = path.relative(rootAbs, abs);
+  const inside = rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
+  if (!inside) {
+    throw new Error(
+      `Access denied: "${p}" resolves outside the workspace root (${rootAbs}).`
+    );
+  }
+  return abs;
+}
+
+module.exports = { sandboxPath };

package/src/tools/shell-tool.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const { exec } = require('child_process');
+const { SHELL_TIMEOUT_MS, SHELL_MAX_BUFFER } = require('../config.js');
+const { sandboxPath } = require('./sandbox.js');
+const { gate } = require('../core/approvals.js');
+
+async function executeShell(args, ctx) {
+  const command = String(args.command || '').trim();
+  if (!command) return 'Error: "command" is required.';
+
+  const allowed = await gate(ctx, `Allow shell command: "${command}" ? [y/N] `, ['full-auto']);
+  if (!allowed) {
+    return 'User declined to run this command. Do not retry it; ask how they want to proceed.';
+  }
+
+  let cwd = ctx.workspaceRoot;
+  if (args.cwd) cwd = sandboxPath(ctx.workspaceRoot, args.cwd);
+
+  return new Promise((resolve) => {
+    exec(
+      command,
+      {
+        cwd,
+        shell: args.shell || true,
+        timeout: SHELL_TIMEOUT_MS,
+        maxBuffer: SHELL_MAX_BUFFER,
+      },
+      (err, stdout, stderr) => {
+        if (err && !stdout && !stderr) {
+          return resolve(`Error running command: ${err.message}`);
+        }
+        let out = `${stdout || ''}${stderr ? (stdout ? '\n' : '') + stderr : ''}`.trim();
+        if (!out) out = '(no output)';
+        if (err && err.killed) out += `\n[command timed out after ${SHELL_TIMEOUT_MS / 1000}s]`;
+        else if (err && typeof err.code === 'number') out += `\n[exit code: ${err.code}]`;
+        resolve(out);
+      }
+    );
+  });
+}
+
+module.exports = { executeShell };

package/src/tools/web-tools.js

@@ -0,0 +1,322 @@
+'use strict';
+
+const dns = require('dns').promises;
+const { FETCH_TIMEOUT_MS, FETCH_MAX_BYTES } = require('../config.js');
+
+function isPrivateIPv4(ip) {
+  const m = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(ip);
+  if (!m) return false;
+  const a = Number(m[1]);
+  const b = Number(m[2]);
+  if (a === 0 || a === 10 || a === 127) return true;
+  if (a === 169 && b === 254) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 192 && b === 168) return true;
+  return false;
+}
+
+function isPrivateIPv6(ip) {
+  const s = ip.toLowerCase();
+  if (s === '::' || s === '::1') return true;
+  if (s.startsWith('fe8') || s.startsWith('fe9') || s.startsWith('fea') || s.startsWith('feb')) {
+    return true;
+  }
+  if (/^f[cd]/.test(s)) return true;
+  const mapped = /^::ffff:(\d{1,3}(?:\.\d{1,3}){3})$/.exec(s);
+  if (mapped) return isPrivateIPv4(mapped[1]);
+  return false;
+}
+
+function assertPublicUrl(urlString) {
+  let url;
+  try {
+    url = new URL(urlString);
+  } catch {
+    throw new Error(`Invalid URL: ${urlString}`);
+  }
+  if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+    throw new Error(`Only http/https URLs are allowed, got "${url.protocol}"`);
+  }
+  const host = url.hostname.replace(/^\[/, '').replace(/\]$/, '').toLowerCase();
+  if (host === 'localhost' || host.endsWith('.localhost')) {
+    throw new Error('Blocked: localhost targets are not allowed.');
+  }
+  const isLiteralV4 = /^\d{1,3}(\.\d{1,3}){3}$/.test(host);
+  const isLiteralV6 = host.includes(':');
+  const addresses = isLiteralV4 || isLiteralV6 ? [{ address: host }] : null;
+  return { url, host, addresses };
+}
+
+async function resolveAndGuard(urlString) {
+  const { url, host, addresses } = assertPublicUrl(urlString);
+  let resolved;
+  if (addresses) {
+    resolved = addresses;
+    if (isPrivateIPv4(host) || isPrivateIPv6(host)) {
+      throw new Error(
+        `Blocked: ${host} is a loopback/link-local/private address. ` +
+          `SSRF protection refuses to fetch internal network targets.`
+      );
+    }
+  } else {
+    try {
+      resolved = await dns.lookup(host, { all: true, verbatim: true });
+    } catch (e) {
+      throw new Error(`Could not resolve host "${host}": ${e.message}`);
+    }
+    for (const entry of resolved) {
+      const addr = entry.address;
+      if (isPrivateIPv4(addr) || isPrivateIPv6(addr)) {
+        throw new Error(
+          `Blocked: ${host} resolves to a loopback/link-local/private address (${addr}). ` +
+            `SSRF protection refuses to fetch internal network targets.`
+        );
+      }
+    }
+  }
+  return url;
+}
+
+const NAMED_ENTITIES = {
+  amp: '&',
+  lt: '<',
+  gt: '>',
+  quot: '"',
+  apos: "'",
+  nbsp: ' ',
+  copy: '\u00A9',
+  reg: '\u00AE',
+  trade: '\u2122',
+  hellip: '\u2026',
+  mdash: '\u2014',
+  ndash: '\u2013',
+  lsquo: '\u2018',
+  rsquo: '\u2019',
+  ldquo: '\u201C',
+  rdquo: '\u201D',
+};
+
+function decodeEntities(text) {
+  return String(text)
+    .replace(/&#x([0-9a-f]+);/gi, (_, hex) => {
+      try {
+        return String.fromCodePoint(parseInt(hex, 16));
+      } catch {
+        return '';
+      }
+    })
+    .replace(/&#(\d+);/g, (_, dec) => {
+      try {
+        return String.fromCodePoint(Number(dec));
+      } catch {
+        return '';
+      }
+    })
+    .replace(/&([a-z]+);/gi, (_, name) => NAMED_ENTITIES[name.toLowerCase()] ?? `&${name};`);
+}
+
+function htmlToText(html) {
+  // Regex-based conversion: good enough for static HTML; JS-rendered pages will
+  // yield only their noscript/static content.
+  let s = String(html);
+  s = s.replace(/<script[\s\S]*?<\/script\s*>/gi, ' ');
+  s = s.replace(/<style[\s\S]*?<\/style\s*>/gi, ' ');
+  s = s.replace(/<noscript[\s\S]*?<\/noscript\s*>/gi, ' ');
+  s = s.replace(/<!--[\s\S]*?-->/g, ' ');
+  s = s.replace(/<svg[\s\S]*?<\/svg\s*>/gi, ' ');
+  s = s.replace(/<br\s*\/?>/gi, '\n');
+  s = s.replace(/<\/(p|div|section|article|header|footer|h[1-6]|li|tr|ul|ol|table|pre|blockquote)>/gi, '\n');
+  s = s.replace(/<[^>]+>/g, ' ');
+  s = decodeEntities(s);
+  s = s.replace(/[ \t\f\v\u00a0]+/g, ' ');
+  s = s.replace(/ ?\n ?/g, '\n');
+  s = s.replace(/\n{3,}/g, '\n\n');
+  return s.trim();
+}
+
+async function fetchCapped(urlString, timeoutMs, maxBytes) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetch(urlString, {
+      signal: controller.signal,
+      redirect: 'follow',
+      headers: {
+        'User-Agent': 'DracoCLI/1.0 (+https://github.com/draco-cli)',
+        Accept: 'text/html,application/json,text/plain;q=0.9,*/*;q=0.5',
+      },
+    });
+    if (!res.ok) {
+      throw new Error(`HTTP ${res.status} ${res.statusText} while fetching ${urlString}`);
+    }
+    if (!res.body) {
+      const text = await res.text();
+      return { text, contentType: res.headers.get('content-type') || '' };
+    }
+    const decoder = new TextDecoder('utf-8', { fatal: false });
+    let total = 0;
+    let text = '';
+    for await (const chunk of res.body) {
+      total += chunk.byteLength;
+      if (total > maxBytes) {
+        controller.abort();
+        throw new Error(
+          `Response exceeded the ${Math.round(maxBytes / (1024 * 1024))}MB size cap.`
+        );
+      }
+      text += decoder.decode(chunk, { stream: true });
+    }
+    text += decoder.decode();
+    return { text, contentType: res.headers.get('content-type') || '' };
+  } catch (e) {
+    if (e.name === 'AbortError') {
+      const timedOut = e.message === undefined;
+      throw new Error(
+        `Request timed out or was aborted after ${Math.round(timeoutMs / 1000)}s${timedOut ? '' : ''}`
+      );
+    }
+    throw e;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function webFetch(args) {
+  const format = args.format === 'html' ? 'html' : 'text';
+  let url;
+  try {
+    url = await resolveAndGuard(String(args.url || ''));
+  } catch (e) {
+    return `Error: ${e.message}`;
+  }
+  try {
+    const { text, contentType } = await fetchCapped(
+      url.href,
+      Number(args.timeoutMs) > 120000 ? 120000 : Number(args.timeoutMs) || FETCH_TIMEOUT_MS,
+      FETCH_MAX_BYTES
+    );
+    if (format === 'html') return text;
+    if (/application\/json/i.test(contentType)) return text;
+    const cleaned = htmlToText(text);
+    return cleaned || '(page contained no readable text)';
+  } catch (e) {
+    return `Error: ${e.message || e}`;
+  }
+}
+
+const SEARCH_PROVIDERS = {
+  async brave(query, apiKey) {
+    const endpoint =
+      'https://api.search.brave.com/res/v1/web/search?' +
+      new URLSearchParams({ q: query, count: '5' }).toString();
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 15000);
+    try {
+      const res = await fetch(endpoint, {
+        signal: controller.signal,
+        headers: {
+          Accept: 'application/json',
+          'Accept-Encoding': 'gzip',
+          'X-Subscription-Token': apiKey,
+        },
+      });
+      if (!res.ok) {
+        const body = await res.text().catch(() => '');
+        throw new Error(`Brave search HTTP ${res.status}: ${body.slice(0, 200)}`);
+      }
+      const data = await res.json();
+      const results = ((data.web && data.web.results) || []).slice(0, 5);
+      return results.map((r) => ({
+        title: r.title,
+        url: r.url,
+        snippet: r.description || '',
+      }));
+    } finally {
+      clearTimeout(timer);
+    }
+  },
+
+  async duckduckgo(query) {
+    const endpoint =
+      'https://html.duckduckgo.com/html/?' +
+      new URLSearchParams({ q: query }).toString();
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 15000);
+    try {
+      const res = await fetch(endpoint, {
+        method: 'POST',
+        signal: controller.signal,
+        headers: {
+          'Content-Type': 'application/x-www-form-urlencoded',
+          'User-Agent':
+            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0 Safari/537.36',
+          Accept: 'text/html,application/xhtml+xml',
+        },
+        body: new URLSearchParams({ q: query }).toString(),
+      });
+      if (!res.ok) {
+        throw new Error(`DuckDuckGo HTTP ${res.status} (may be rate-limited — retry later or set DRACO_SEARCH_API_KEY to use Brave)`);
+      }
+      const html = await res.text();
+      const clean = (s) =>
+        decodeEntities(String(s).replace(/<[^>]+>/g, '')).replace(/\s+/g, ' ').trim();
+      const unwrap = (u) => {
+        if (u.startsWith('//')) u = 'https:' + u;
+        try {
+          const parsed = new URL(u);
+          const target = parsed.searchParams.get('uddg');
+          return target ? decodeURIComponent(target) : u;
+        } catch {
+          return u;
+        }
+      };
+      const anchorRe = /<a[^>]*class="[^"]*result__a[^"]*"[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/g;
+      const snippetRe = /<a[^>]*class="[^"]*result__snippet[^"]*"[^>]*>([\s\S]*?)<\/a>/g;
+      const links = [];
+      let m;
+      while ((m = anchorRe.exec(html)) !== null && links.length < 8) {
+        links.push({ url: unwrap(m[1]), title: clean(m[2]) });
+      }
+      const snippets = [];
+      while ((m = snippetRe.exec(html)) !== null && snippets.length < 8) {
+        snippets.push(clean(m[1]));
+      }
+      const seen = new Set();
+      const results = [];
+      for (let i = 0; i < links.length && results.length < 5; i++) {
+        const r = { title: links[i].title, url: links[i].url, snippet: snippets[i] || '' };
+        if (!r.url || seen.has(r.url)) continue;
+        seen.add(r.url);
+        results.push(r);
+      }
+      return results;
+    } finally {
+      clearTimeout(timer);
+    }
+  },
+};
+
+async function webSearch(args, cfg) {
+  const query = String(args.query || '').trim();
+  if (!query) return 'Error: query is required.';
+  const providerName = cfg.searchApiKey ? (cfg.searchProvider || 'brave') : 'duckduckgo';
+  const impl = SEARCH_PROVIDERS[providerName];
+  if (!impl) return `Error: unknown search provider "${providerName}".`;
+  try {
+    const results = await impl(query, cfg.searchApiKey);
+    if (!results.length) return `No results found for "${query}".`;
+    return results
+      .map((r, i) => `${i + 1}. ${r.title}\n   ${r.url}${r.snippet ? `\n   ${r.snippet}` : ''}`)
+      .join('\n\n');
+  } catch (e) {
+    return `Error: search failed — ${e.message || e}`;
+  }
+}
+
+module.exports = {
+  assertPublicUrl,
+  resolveAndGuard,
+  htmlToText,
+  webFetch,
+  webSearch,
+};

package/src/ui/diff.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const tty = process.stdout.isTTY;
+
+const col = {
+  reset: tty ? '\x1b[0m' : '',
+  dim: tty ? '\x1b[2m' : '',
+  red: tty ? '\x1b[31m' : '',
+  green: tty ? '\x1b[32m' : '',
+  cyan: tty ? '\x1b[36m' : '',
+};
+
+function splitLines(text) {
+  return String(text ?? '').split('\n');
+}
+
+function diffLines(oldText, newText) {
+  const a = splitLines(oldText);
+  const b = splitLines(newText);
+  let start = 0;
+  while (start < a.length && start < b.length && a[start] === b[start]) start++;
+  let endA = a.length;
+  let endB = b.length;
+  while (endA > start && endB > start && a[endA - 1] === b[endB - 1]) {
+    endA--;
+    endB--;
+  }
+  const rows = [];
+  for (let i = Math.max(0, start - 3); i < start; i++) rows.push({ type: ' ', text: a[i] });
+  for (let i = start; i < endA; i++) rows.push({ type: '-', text: a[i] });
+  for (let i = start; i < endB; i++) rows.push({ type: '+', text: b[i] });
+  const tailStart = Math.min(a.length, endA + 3);
+  for (let i = endA; i < tailStart; i++) rows.push({ type: ' ', text: a[i] });
+  return rows;
+}
+
+function renderDiff(rows, maxRows = 120) {
+  const shown = rows.slice(0, maxRows);
+  const parts = [];
+  parts.push(`${col.dim}\u2500\u2500 diff ${'─'.repeat(24)}${col.reset}`);
+  for (const row of shown) {
+    if (row.type === '+') parts.push(`${col.green}+ ${row.text}${col.reset}`);
+    else if (row.type === '-') parts.push(`${col.red}- ${row.text}${col.reset}`);
+    else parts.push(`${col.dim}  ${row.text}${col.reset}`);
+  }
+  if (rows.length > shown.length) {
+    parts.push(`${col.cyan}\u2026 ${rows.length - shown.length} more lines${col.reset}`);
+  }
+  parts.push(`${col.dim}\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500${col.reset}`);
+  return parts.join('\n');
+}
+
+module.exports = { diffLines, renderDiff };

package/src/ui/markdown.js

@@ -0,0 +1,106 @@
+'use strict';
+
+const theme = require('./theme.js');
+
+const tty = process.stdout.isTTY;
+
+const c = theme.c;
+
+function inline(line) {
+  let out = line;
+  out = out.replace(/`([^`]+)`/g, `${c.yellow}$1${c.reset}`);
+  out = out.replace(/\*\*([^*]+)\*\*/g, `${c.bold}$1${c.reset}`);
+  out = out.replace(/(^|[\s(])\*([^*\s][^*]*)\*/g, `$1${c.italic}$2${c.reset}`);
+  return out;
+}
+
+function renderLine(line, state) {
+  if (state.fence) {
+    if (/^\s*```/.test(line)) {
+      state.fence = false;
+      return `${c.dim}└─ code${c.reset}`;
+    }
+    return `${c.blue}${line}${c.reset}`;
+  }
+  const fence = /^\s*```(.*)$/.exec(line);
+  if (fence) {
+    state.fence = true;
+    const lang = (fence[1] || '').trim();
+    return `${c.dim}┌─ code${lang ? ` ${lang}` : ''}${c.reset}`;
+  }
+  const h = /^(#{1,6})\s+(.*)$/.exec(line);
+  if (h) {
+    const level = h[1].length;
+    const color = level <= 2 ? c.bold : c.magenta || c.purple;
+    return `${color}${h[2]}${c.reset}`;
+  }
+  const bullet = /^(\s*)[-*]\s+(.*)$/.exec(line);
+  if (bullet) {
+    return `${bullet[1]}${c.cyan}•${c.reset} ${inline(bullet[2])}`;
+  }
+  const numbered = /^(\s*)(\d+\.)\s+(.*)$/.exec(line);
+  if (numbered) {
+    return `${numbered[1]}${c.cyan}${numbered[2]}${c.reset} ${inline(numbered[3])}`;
+  }
+  return inline(line);
+}
+
+class MarkdownStream {
+  constructor() {
+    this.buffer = '';
+    this.state = { fence: false };
+    this.started = false;
+    this.blockOpen = false;
+  }
+
+  openBlock() {
+    if (!tty || this.blockOpen) return;
+    this.blockOpen = true;
+    process.stdout.write(theme.responseRule('top') + '\n');
+  }
+
+  closeBlock() {
+    if (!tty || !this.blockOpen) return;
+    this.blockOpen = false;
+    process.stdout.write(theme.responseRule('bottom') + '\n');
+  }
+
+  write(chunk) {
+    if (!tty) {
+      process.stdout.write(chunk);
+      return;
+    }
+    this.buffer += chunk;
+    let nl;
+    while ((nl = this.buffer.indexOf('\n')) >= 0) {
+      const line = this.buffer.slice(0, nl + 1);
+      this.buffer = this.buffer.slice(nl + 1);
+      this.flushLine(line);
+    }
+  }
+
+  flushLine(lineWithNewline) {
+    const hadNewline = lineWithNewline.endsWith('\n');
+    const text = hadNewline ? lineWithNewline.slice(0, -1) : lineWithNewline;
+    this.openBlock();
+    if (text.trim() === '') {
+      process.stdout.write(theme.gutter() + (hadNewline ? '\n' : ''));
+      return;
+    }
+    process.stdout.write(
+      `${theme.gutter()} ${renderLine(text, this.state)}` + (hadNewline ? '\n' : '')
+    );
+  }
+
+  end() {
+    if (!tty) return;
+    if (this.buffer.length > 0) {
+      const rest = this.buffer;
+      this.buffer = '';
+      this.flushLine(rest.endsWith('\n') ? rest : `${rest}\n`);
+    }
+    this.closeBlock();
+  }
+}
+
+module.exports = { MarkdownStream };