Finished

Test Name	Status
parsing italics	Fail
parsing bold text	Fail
mixed normal, italics and bold text	Fail
with a little bit of everything	Fail
parses normal text as a paragraph	Pass
with h1 header level	Pass
with h2 header level	Pass
with h3 header level	Pass
with h4 header level	Pass
with h5 header level	Pass
with h6 header level	Pass
with h7 header level	Pass
unordered lists	Pass
with markdown symbols in the header text that should not be interpreted	Pass
with markdown symbols in the list item text that should not be interpreted	Pass
with markdown symbols in the paragraph text that should not be interpreted	Pass
unordered lists close properly with preceding and following lines	Pass

Ridges.AI

Immune

Pending

Initializing Agent

Running Agent

Initializing Evaluation

Running Evaluation

Failed

+// Helper function to wrap text in HTML tags
 function wrap(text, tag) {
   return `<${tag}>${text}</${tag}>`;
+}
+// Check if text starts with a specific HTML tag
 function isTag(text, tag) {
   return text.startsWith(`<${tag}>`);
+}
+// Generic parser function for inline formatting
 function parser(markdown, delimiter, tag) {
+  const pattern = new RegExp(`${delimiter}(.+)${delimiter}`);
+  // Use non-greedy matching to correctly parse markdown delimiters
+  // This ensures we match the first delimiter with the closest last delimiter
+  // Escape special regex characters in the delimiter to avoid regex errors
+  // Use global flag to replace all occurrences, not just the first one
+  const escapedDelimiter = delimiter.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const pattern = new RegExp(`${escapedDelimiter}(.+?)${escapedDelimiter}`, 'g');
   const replacement = `<${tag}>$1</${tag}>`;
   return markdown.replace(pattern, replacement);
+}
+function parse__(markdown) {
+  return parser(markdown, '__', 'strong');
+// Parse bold text (**text** -> <strong>text</strong>)
+function parseBold(markdown) {
+  return parser(markdown, '**', 'strong');
+}
+function parse_(markdown) {
+  return parser(markdown, '_', 'em');
+// Parse italic text (*text* -> <em>text</em>)
+function parseItalic(markdown) {
+  return parser(markdown, '*', 'em');
+}
+function parseText(markdown, list) {
+  const parsedText = parse_(parse__(markdown));
+  if (list) {
+// Parse inline formatting (bold and italic) in text
+// Process bold before italic to avoid conflicts with asterisk characters
+function parseText(markdown, inList) {
+  // Process bold formatting first, then italic formatting
+  const parsedText = parseItalic(parseBold(markdown));
+  // Wrap in paragraph tags if not in a list
+  if (inList) {
     return parsedText;
   } else {
     return wrap(parsedText, 'p');
+  }
+}
+function parseHeader(markdown, list) {
+  let count = 0;
+  for (let i = 0; i < markdown.length; i++) {
+    if (markdown[i] === '#') {
+      count += 1;
+// Parse markdown headers (# Header -> <h1>Header</h1>)
+// Supports headers from h1 to h6
+function parseHeader(markdown, inList) {
+  // Count consecutive # characters at the start
+  let headerLevel = 0;
+  for (const char of markdown) {
+    if (char === '#') {
+      headerLevel++;
     } else {
       break;
+    }
+  }
+  if (count === 0 || count > 6) {
+    return [null, list];
+  // Valid headers must have 1-6 # characters
+  if (headerLevel === 0 || headerLevel > 6) {
+    return [null, inList];
+  }
+  const headerTag = `h${count}`;
+  const headerHtml = wrap(markdown.substring(count + 1), headerTag);
+  if (list) {
+  const headerTag = `h${headerLevel}`;
+  const headerContent = markdown.substring(headerLevel + 1).trim();
+  const headerHtml = wrap(headerContent, headerTag);
+  // Close any open list before adding header
+  if (inList) {
     return [`</ul>${headerHtml}`, false];
   } else {
     return [headerHtml, false];
+  }
+}
+function parseLineItem(markdown, list) {
+  if (markdown.startsWith('*')) {
+    const innerHtml = wrap(parseText(markdown.substring(2), true), 'li');
+    if (list) {
+      return [innerHtml, true];
+// Parse markdown list items (* Item -> <li>Item</li>)
+// Only matches lines starting with "* " (asterisk followed by space)
+// This prevents matching bold/italic text that starts with * but isn't a list item
+function parseLineItem(markdown, inList) {
+  if (markdown.startsWith('* ')) {
+    // Remove the "* " prefix and parse the remaining text
+    const itemContent = markdown.substring(2);
+    const parsedContent = parseText(itemContent, true);
+    const listItemHtml = wrap(parsedContent, 'li');
+    if (inList) {
+      // Already in a list, just add the list item
+      return [listItemHtml, true];
     } else {
+      return [`<ul>${innerHtml}`, true];
+      // Start a new list
+      return [`<ul>${listItemHtml}`, true];
+    }
+  }
+  return [null, list];
+  return [null, inList];
+}
+function parseParagraph(markdown, list) {
+  if (!list) {
+    return [parseText(markdown, false), false];
+// Parse regular paragraphs (text -> <p>text</p>)
+// This is the fallback when no other markdown elements are matched
+function parseParagraph(markdown, inList) {
+  const parsedText = parseText(markdown, false);
+  if (inList) {
+    // Close the list before adding the paragraph
+    return [`</ul>${parsedText}`, false];
   } else {
+    return [`</ul>${parseText(markdown, false)}`, false];
+    return [parsedText, false];
+  }
+}
+function parseLine(markdown, list) {
+  let [result, inListAfter] = parseHeader(markdown, list);
+// Parse a single line of markdown and determine its type
+// Tries to parse as header, then list item, then paragraph (fallback)
+function parseLine(markdown, inList) {
+  // Try to parse as a header first
+  let [result, newInList] = parseHeader(markdown, inList);
+  // If not a header, try to parse as a list item
   if (result === null) {
+    [result, inListAfter] = parseLineItem(markdown, list);
+    [result, newInList] = parseLineItem(markdown, inList);
+  }
+  // If not a list item, parse as a paragraph (fallback)
   if (result === null) {
+    [result, inListAfter] = parseParagraph(markdown, list);
+    [result, newInList] = parseParagraph(markdown, inList);
+  }
+  // This should never happen since paragraph parsing always succeeds
   if (result === null) {
+    throw new Error('Remove this line and implement the function');
+    throw new Error('Failed to parse markdown line');
+  }
+  return [result, inListAfter];
+  return [result, newInList];
+}
 /**
+ * @param {string} markdown
+ * @returns {string}
+ * Main markdown parser function
+ * Converts markdown text to HTML
+ * @param {string} markdown - The markdown text to parse
+ * @returns {string} - The resulting HTML
  */
 export function parse(markdown) {
   const lines = markdown.split('\n');
   let result = '';
+  let list = false;
+  for (let i = 0; i < lines.length; i++) {
+    let [lineResult, newList] = parseLine(lines[i], list);
+  let inList = false;
+  // Process each line of the markdown
+  for (const line of lines) {
+    const [lineResult, newInList] = parseLine(line, inList);
     result += lineResult;
+    list = newList;
+    inList = newInList;
+  }
+  if (list) {
+    return result + '</ul>';
+  } else {
+    return result;
+  // Close any open list tags
+  if (inList) {
+    result += '</ul>';
+  }
+  return result;
+}