refactor: replace regex-based stripMarkdownInline with render-then-strip-ANSI

Eliminate the entire stripMarkdownInline() function and its accumulated
edge-case bugs (code span precedence, underscore corruption, backslash
escapes). Instead, reuse the existing marked.lexer() → renderInline()
pipeline for both TTY and plain modes, stripping ANSI from the result
in plain mode — the same approach renderMarkdown() already uses.

Key changes:
- renderInlineMarkdown(): always renders through marked, strips ANSI in
  plain mode instead of calling stripMarkdownInline()
- renderCodespan(): extracted helper; skips padding spaces in plain mode
  so table column widths aren't inflated
- formatTable/formatTraceTable/formatLogTable: merged TTY and plain
  branches into a single renderInlineMarkdown() call
- mdRow(): same — single code path for both modes
- Deleted stripMarkdownInline() entirely

Author: BYK

src/lib/formatters/log.ts

@@ -10,13 +10,11 @@ import {
   colorTag,
   escapeMarkdownCell,
   escapeMarkdownInline,
-  isPlainOutput,
   mdKvTable,
   mdRow,
   mdTableHeader,
   renderInlineMarkdown,
   renderMarkdown,
-  stripMarkdownInline,
 } from "./markdown.js";
 import {
   renderTextTable,
@@ -175,16 +173,6 @@ export function formatLogsHeader(): string {
  */
 export function formatLogTable(logs: LogLike[], includeTrace = true): string {
   const headers = [...LOG_TABLE_COLS];
-
-  if (isPlainOutput()) {
-    const rows = logs.map((log) =>
-      buildLogRowCells(log, false, includeTrace).map((c) =>
-        stripMarkdownInline(c)
-      )
-    );
-    return renderTextTable(headers, rows);
-  }
-
   const rows = logs.map((log) =>
     buildLogRowCells(log, false, includeTrace).map((c) =>
       renderInlineMarkdown(c)

src/lib/formatters/markdown.ts

@@ -94,19 +94,11 @@ export function mdTableHeader(cols: readonly string[]): string {
  * in rendered mode applies inline styling and replaces `|` with `│`.
  */
 export function mdRow(cells: readonly string[]): string {
-  if (isPlainOutput()) {
-    // Strip markdown syntax, then replace literal pipes with box-drawing │
-    // to prevent them from breaking the pipe-delimited table format.
-    const stripped = cells.map((c) =>
-      stripMarkdownInline(c).replace(/\|/g, "\u2502")
-    );
-    return `| ${stripped.join(" | ")} |\n`;
-  }
+  // Both modes render through the same pipeline; plain mode strips ANSI.
+  // Literal pipes are replaced with box-drawing │ to prevent breaking the
+  // pipe-delimited table format.
   const out = cells.map((c) =>
-    renderInline(marked.lexer(c).flatMap(flattenInline)).replace(
-      /\|/g,
-      "\u2502"
-    )
+    renderInlineMarkdown(c).replace(/\|/g, "\u2502")
   );
   return `| ${out.join(" | ")} |\n`;
 }
@@ -216,32 +208,6 @@ export function stripColorTags(text: string): string {
   return result;
 }
 
-/**
- * Strip inline markdown syntax to produce plain text.
- *
- * Removes bold/italic markers, link syntax (keeps display text), code
- * backticks, and color tags. Used for plain-mode output that should be
- * human-readable without any markdown artifacts.
- */
-export function stripMarkdownInline(md: string): string {
-  let text = stripColorTags(md);
-  // Links: [text](url) → text
-  text = text.replace(/\[([^\]]*)\]\([^)]*\)/g, "$1");
-  // Code spans first (higher precedence than emphasis in CommonMark):
-  // `text` → text. Content inside backticks is literal, so bold/italic
-  // markers inside code spans must not be stripped.
-  text = text.replace(/`([^`]+)`/g, "$1");
-  // Bold: **text** → text. Only strip asterisk-based emphasis, not
-  // underscore-based (_text_) because underscores appear in identifiers
-  // (e.g. payment_service_handler) and would be corrupted.
-  text = text.replace(/\*{1,2}([^*]+)\*{1,2}/g, "$1");
-  // Backslash escapes: \| \< \> \\ \_ \* \[ \] \` → literal character.
-  // escapeMarkdownCell/escapeMarkdownInline add these for the markdown parser;
-  // the TTY path unescapes via marked.lexer(), but plain mode must do it here.
-  text = text.replace(/\\([|<>\\*_`[\]])/g, "$1");
-  return text;
-}
-
 /**
  * Render an inline HTML token as a color-tagged string.
  *
@@ -296,19 +262,31 @@ function flattenInline(token: Token): Token[] {
   return [token];
 }
 
+/**
+ * Render a code span token.
+ *
+ * Plain mode: raw text without padding so table column widths aren't inflated.
+ * TTY mode: styled with background color and padded spaces for visual weight.
+ */
+function renderCodespan(token: Tokens.Codespan): string {
+  if (isPlainOutput()) {
+    return token.text;
+  }
+  return chalk.bgHex(COLORS.codeBg).hex(COLORS.codeFg)(` ${token.text} `);
+}
+
 /**
  * Render a single inline token to an ANSI string.
  */
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: inline token switch is inherently branchy
 function renderOneInline(token: Token): string {
   switch (token.type) {
     case "strong":
       return chalk.bold(renderInline((token as Tokens.Strong).tokens));
     case "em":
       return chalk.italic(renderInline((token as Tokens.Em).tokens));
     case "codespan":
-      return chalk.bgHex(COLORS.codeBg).hex(COLORS.codeFg)(
-        ` ${(token as Tokens.Codespan).text} `
-      );
+      return renderCodespan(token as Tokens.Codespan);
     case "link": {
       const link = token as Tokens.Link;
       let linkText = renderInline(link.tokens);
@@ -584,13 +562,16 @@ export function renderMarkdown(md: string): string {
  * Render inline markdown (bold, code spans, emphasis, links) as styled
  * terminal output, or return plain text when in plain mode.
  *
+ * Both modes use the same `marked.lexer()` → `renderInline()` pipeline.
+ * In plain mode, ANSI codes are stripped from the result, producing
+ * clean text. This avoids maintaining a separate regex-based stripping
+ * function that would need to replicate the markdown parser's rules.
+ *
  * @param md - Inline markdown text
- * @returns Styled string (TTY) or plain text with markdown syntax stripped (non-TTY / plain mode)
+ * @returns Styled string (TTY) or plain text (non-TTY / plain mode)
  */
 export function renderInlineMarkdown(md: string): string {
-  if (isPlainOutput()) {
-    return stripMarkdownInline(md);
-  }
   const tokens = marked.lexer(md);
-  return renderInline(tokens.flatMap(flattenInline));
+  const rendered = renderInline(tokens.flatMap(flattenInline));
+  return isPlainOutput() ? stripAnsi(rendered) : rendered;
 }

src/lib/formatters/table.ts

@@ -15,7 +15,6 @@ import {
   isPlainOutput,
   renderInlineMarkdown,
   stripColorTags,
-  stripMarkdownInline,
 } from "./markdown.js";
 import { type Alignment, renderTextTable } from "./text-table.js";
 
@@ -94,9 +93,9 @@ export type WriteTableOptions = {
  * Format items as a table string.
  *
  * Returns the rendered table instead of writing to a stream.
- * In plain/non-TTY mode emits a human-readable aligned table with
- * Unicode box-drawing borders but no ANSI escape codes. In TTY mode
- * emits a styled table with ANSI colors and hyperlinks.
+ * Cell values are markdown strings rendered through {@link renderInlineMarkdown},
+ * which produces ANSI-styled text in TTY mode and clean plain text when piped.
+ * In plain mode, row separator ANSI coloring is stripped to `true` (plain borders).
  */
 export function formatTable<T>(
   items: T[],
@@ -108,23 +107,6 @@ export function formatTable<T>(
   const minWidths = columns.map((c) => c.minWidth ?? 0);
   const shrinkable = columns.map((c) => c.shrinkable ?? true);
 
-  if (isPlainOutput()) {
-    // Strip markdown syntax so plain output is human-readable (no **bold**,
-    // [link](url), or `code` artifacts). Use renderTextTable for proper
-    // column alignment with box-drawing borders.
-    const rows = items.map((item) =>
-      columns.map((c) => stripMarkdownInline(c.value(item)))
-    );
-    return renderTextTable(headers, rows, {
-      alignments,
-      minWidths,
-      shrinkable,
-      truncate: options?.truncate,
-      // Strip ANSI color from row separators in plain mode
-      rowSeparator: Boolean(options?.rowSeparator),
-    });
-  }
-
   const rows = items.map((item) =>
     columns.map((c) => renderInlineMarkdown(c.value(item)))
   );
@@ -134,7 +116,10 @@ export function formatTable<T>(
     minWidths,
     shrinkable,
     truncate: options?.truncate,
-    rowSeparator: options?.rowSeparator,
+    // Strip ANSI color from row separators in plain mode
+    rowSeparator: isPlainOutput()
+      ? Boolean(options?.rowSeparator)
+      : options?.rowSeparator,
   });
 }
 

src/lib/formatters/trace.ts

@@ -14,13 +14,11 @@ import {
   colorTag,
   escapeMarkdownCell,
   escapeMarkdownInline,
-  isPlainOutput,
   mdKvTable,
   mdRow,
   mdTableHeader,
   renderInlineMarkdown,
   renderMarkdown,
-  stripMarkdownInline,
 } from "./markdown.js";
 import { type Column, formatTable } from "./table.js";
 import { renderTextTable } from "./text-table.js";
@@ -125,14 +123,6 @@ export function formatTraceTable(items: TransactionListItem[]): string {
   const alignments = TRACE_TABLE_COLS.map((c) =>
     c.endsWith(":") ? ("right" as const) : ("left" as const)
   );
-
-  if (isPlainOutput()) {
-    const rows = items.map((item) =>
-      buildTraceRowCells(item).map((c) => stripMarkdownInline(c))
-    );
-    return renderTextTable(headers, rows, { alignments });
-  }
-
   const rows = items.map((item) =>
     buildTraceRowCells(item).map((c) => renderInlineMarkdown(c))
   );

test/commands/project/create.test.ts

@@ -490,9 +490,9 @@ describe("project create", () => {
     await func.call(context, { json: false }, "my-app", "node");
 
     const output = stdoutWrite.mock.calls.map((c) => c[0]).join("");
-    // Plain mode strips backtick code spans
-    expect(output).toContain("Slug  my-app-0g  was assigned");
-    expect(output).toContain("my-app  is already taken");
+    // Plain mode renders code spans as plain text without padding
+    expect(output).toContain("Slug my-app-0g was assigned");
+    expect(output).toContain("my-app is already taken");
   });
 
   test("does not show slug note when slug matches name", async () => {