omnibiofex 2.6.1 → 2.6.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnibiofex",
-  "version": "2.6.1",
+  "version": "2.6.3",
   "description": "OmniBioFex X - The Autonomous Research Terminal for AI-powered research missions",
   "main": "bin/obx",
   "bin": {

package/src/utils/display.js

@@ -344,14 +344,136 @@ function addVisualBreak() {
   console.log(chalk.gray('\n' + '·'.repeat(60) + '\n'));
 }
 
-// ==================== TYPE AI RESPONSE (IMPROVED) ====================
+// ==================== INLINE MARKDOWN PARSER ====================
+
+/**
+ * Parse a line and return array of segments with formatting
+ * Handles: **bold**, *italic*, `code`, and combinations
+ */
+function parseInlineMarkdown(text) {
+  const segments = [];
+  let remaining = text;
+  
+  while (remaining.length > 0) {
+    // Find the next markdown pattern
+    const boldMatch = remaining.match(/\*\*(.+?)\*\*/);
+    const italicMatch = remaining.match(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/);
+    const codeMatch = remaining.match(/`([^`]+)`/);
+    
+    // Find earliest match
+    let earliest = null;
+    let earliestIndex = remaining.length;
+    
+    if (boldMatch && boldMatch.index < earliestIndex) {
+      earliest = { type: 'bold', match: boldMatch, index: boldMatch.index };
+      earliestIndex = boldMatch.index;
+    }
+    if (codeMatch && codeMatch.index < earliestIndex) {
+      earliest = { type: 'code', match: codeMatch, index: codeMatch.index };
+      earliestIndex = codeMatch.index;
+    }
+    if (italicMatch && italicMatch.index < earliestIndex) {
+      earliest = { type: 'italic', match: italicMatch, index: italicMatch.index };
+      earliestIndex = italicMatch.index;
+    }
+    
+    if (!earliest) {
+      // No more markdown, add remaining as plain text
+      if (remaining.length > 0) {
+        segments.push({ text: remaining, style: 'plain' });
+      }
+      break;
+    }
+    
+    // Add text before the match
+    if (earliestIndex > 0) {
+      segments.push({ 
+        text: remaining.substring(0, earliestIndex), 
+        style: 'plain' 
+      });
+    }
+    
+    // Add the formatted segment
+    segments.push({ 
+      text: earliest.match[1], 
+      style: earliest.type 
+    });
+    
+    // Continue with remaining text
+    remaining = remaining.substring(earliestIndex + earliest.match[0].length);
+  }
+  
+  return segments;
+}
+
+/**
+ * Type a line with inline markdown formatting (bold, italic, code)
+ */
+async function typeFormattedLine(text, speed = 8) {
+  const segments = parseInlineMarkdown(text);
+  
+  for (const segment of segments) {
+    let colorFn = chalk.white;
+    
+    switch (segment.style) {
+      case 'bold':
+        colorFn = chalk.white.bold;
+        break;
+      case 'italic':
+        colorFn = chalk.white.italic;
+        break;
+      case 'code':
+        colorFn = chalk.bgBlack.cyan;
+        break;
+      case 'plain':
+      default:
+        colorFn = chalk.white;
+    }
+    
+    await typeText(segment.text, speed, colorFn);
+  }
+  
+  process.stdout.write('\n');
+}
+
+/**
+ * Type a line with inline markdown, but use gray color for plain text
+ */
+async function typeFormattedLineGray(text, speed = 6) {
+  const segments = parseInlineMarkdown(text);
+  
+  for (const segment of segments) {
+    let colorFn = chalk.gray;
+    
+    switch (segment.style) {
+      case 'bold':
+        colorFn = chalk.white.bold;
+        break;
+      case 'italic':
+        colorFn = chalk.white.italic;
+        break;
+      case 'code':
+        colorFn = chalk.bgBlack.cyan;
+        break;
+      case 'plain':
+      default:
+        colorFn = chalk.gray;
+    }
+    
+    await typeText(segment.text, speed, colorFn);
+  }
+  
+  process.stdout.write('\n');
+}
+
+// ==================== UPDATED AI RESPONSE RENDERER ====================
+
 async function typeAIResponse(response) {
   console.log(chalk.hex('#F24E1E').bold('\n📄 Research Report\n'));
   console.log(chalk.gray('═'.repeat(60)) + '\n');
   
   const lines = response.split('\n');
   let inTable = false;
-  let tableBuffer = [];
   
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
@@ -368,28 +490,53 @@ async function typeAIResponse(response) {
     
     // Detect table rows (lines with |)
     if (trimmed.includes('|') && trimmed.startsWith('|')) {
+      // Skip separator rows like |---|---| or | ---------- |
+      if (trimmed.match(/^\|[\s\-:]+\|$/)) {
+        continue;
+      }
+      
       if (!inTable) {
         inTable = true;
         console.log(chalk.gray('┌' + '─'.repeat(58) + '┐'));
       }
       
-      // Skip separator rows like |---|---|
-      if (trimmed.match(/^\|[\s\-:]+\|$/)) {
-        continue;
-      }
-      
       // Parse table cells
       const cells = trimmed.split('|').filter(c => c.trim() !== '').map(c => c.trim());
       
-      // Format table row
+      // Format table row with inline markdown support
       if (cells.length > 0) {
         const isHeader = i === 0 || (i > 0 && lines[i-1].trim() === '');
-        const formattedRow = cells.map(cell => {
-          const padded = cell.padEnd(14);
-          return isHeader ? chalk.white.bold(padded) : chalk.gray(padded);
-        }).join(' │ ');
         
-        console.log(chalk.gray('│ ') + formattedRow + chalk.gray(' │'));
+        process.stdout.write(chalk.gray('│ '));
+        
+        for (let j = 0; j < cells.length; j++) {
+          const cell = cells[j];
+          const padded = cell.padEnd(15);
+          
+          if (isHeader) {
+            // Header cells - parse markdown and make bold
+            const segments = parseInlineMarkdown(padded);
+            for (const seg of segments) {
+              process.stdout.write(chalk.white.bold(seg.text));
+            }
+          } else {
+            // Regular cells - parse markdown
+            const segments = parseInlineMarkdown(padded);
+            for (const seg of segments) {
+              let colorFn = chalk.gray;
+              if (seg.style === 'bold') colorFn = chalk.white.bold;
+              else if (seg.style === 'italic') colorFn = chalk.white.italic;
+              else if (seg.style === 'code') colorFn = chalk.bgBlack.cyan;
+              process.stdout.write(colorFn(seg.text));
+            }
+          }
+          
+          if (j < cells.length - 1) {
+            process.stdout.write(chalk.gray(' │ '));
+          }
+        }
+        
+        console.log(chalk.gray(' │'));
         await sleep(50);
       }
       
@@ -406,7 +553,8 @@ async function typeAIResponse(response) {
     if (trimmed.startsWith('## ')) {
       const header = trimmed.substring(3);
       console.log('');
-      await typeLine(chalk.hex('#F24E1E').bold(`▸ ${header}`), 15);
+      process.stdout.write(chalk.hex('#F24E1E').bold('▸ '));
+      await typeFormattedLine(header, 15);
       console.log(chalk.gray('─'.repeat(60)));
       await sleep(150);
       continue;
@@ -415,7 +563,8 @@ async function typeAIResponse(response) {
     if (trimmed.startsWith('# ')) {
       const header = trimmed.substring(2);
       console.log('');
-      await typeLine(chalk.hex('#F24E1E').bold.underline(header), 20);
+      process.stdout.write(chalk.hex('#F24E1E').bold.underline('  '));
+      await typeFormattedLine(header, 20);
       console.log('');
       await sleep(200);
       continue;
@@ -425,8 +574,7 @@ async function typeAIResponse(response) {
     if (trimmed.startsWith('• ') || trimmed.startsWith('- ') || trimmed.startsWith('* ')) {
       const bullet = trimmed.substring(2);
       process.stdout.write(chalk.hex('#F24E1E')('  ▸ '));
-      await typeText(bullet, 8, chalk.white);
-      console.log('');
+      await typeFormattedLine(bullet, 8);
       await sleep(60);
       continue;
     }
@@ -437,22 +585,14 @@ async function typeAIResponse(response) {
       const num = numberedMatch[1];
       const text = numberedMatch[2];
       process.stdout.write(chalk.hex('#F24E1E')(`  ${num}. `));
-      await typeText(text, 8, chalk.white);
-      console.log('');
+      await typeFormattedLine(text, 8);
       await sleep(60);
       continue;
     }
     
-    // Bold text (**text**)
-    if (trimmed.startsWith('**') && trimmed.endsWith('**')) {
-      const bold = trimmed.replace(/\*\*/g, '');
-      await typeLine(`  ${bold}`, 10, chalk.white.bold);
-      await sleep(80);
-      continue;
-    }
-    
-    // Regular paragraph
-    await typeLine(`  ${trimmed}`, 6, chalk.gray);
+    // Regular paragraph (with inline markdown support)
+    process.stdout.write('  ');
+    await typeFormattedLineGray(trimmed, 6);
     await sleep(40);
   }