omnibiofex 2.4.1 → 2.4.2

package/bin/obx

@@ -6,10 +6,16 @@ const { login, logout } = require('../src/auth');
 const { missionCreate, missionStatus, missionResults, missionList } = require('../src/commands/mission');
 const { literatureReview, gaps, hypothesis } = require('../src/commands/research');
 const { credits, usage, buy } = require('../src/commands/account');
+const { debug } = require('../src/commands/debug');
+
 
 console.log(chalk.hex('#F24E1E')(figlet.textSync('OmniBioFex X', { horizontalLayout: 'full' })));
 console.log(chalk.gray('The Autonomous Research Terminal v2.4.1\n'));
 
+program
+  .command('debug')
+  .description('Debug authentication and token status')
+  .action(debug);
 program
   .command('login').description('Authenticate').action(login);
 program

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "omnibiofex",
-  "version": "2.4.1",
+  "version": "2.4.2",
   "description": "OmniBioFex X - The Autonomous Research Terminal for AI-powered research missions",
   "main": "bin/obx",
   "bin": {
-    "obx": "bin/obx"
+    "obx": "./bin/obx"
   },
   "scripts": {
     "start": "node bin/obx",
@@ -16,12 +16,7 @@
     "terminal",
     "cli",
     "autonomous",
-    "omnibiofex",
-    "academic",
-    "scientific",
-    "literature-review",
-    "research-agent",
-    "multi-agent"
+    "omnibiofex"
   ],
   "author": {
     "name": "OmniBioFex",
@@ -30,13 +25,6 @@
   },
   "license": "MIT",
   "homepage": "https://x.omnibiofex.cloud",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/omnibiofex/omnibiofex-cli.git"
-  },
-  "bugs": {
-    "url": "https://github.com/omnibiofex/omnibiofex-cli/issues"
-  },
   "engines": {
     "node": ">=14.0.0"
   },

package/src/api.js

@@ -7,11 +7,16 @@ const apiClient = axios.create({
   timeout: 540000, // 9 minutes
 });
 
-// Add auth header to all requests
-apiClient.interceptors.request.use((requestConfig) => {
-  const token = getAuthToken();
-  requestConfig.headers.Authorization = `Bearer ${token}`;
-  return requestConfig;
+// 🔥 FIX: Make the interceptor async to handle async getAuthToken()
+apiClient.interceptors.request.use(async (requestConfig) => {
+  try {
+    const token = await getAuthToken(); // 🔥 Now properly awaits the token
+    requestConfig.headers.Authorization = `Bearer ${token}`;
+    return requestConfig;
+  } catch (error) {
+    console.error(chalk.red('Failed to get auth token:'), error.message);
+    throw error;
+  }
 });
 
 // Handle errors
@@ -55,7 +60,7 @@ async function getUserCredits() {
     const response = await apiClient.get('https://getusercredits-yyedhmslhq-uc.a.run.app');
     return {
       balance: response.data.tokens || 0,
-      used: 0, // You can track this later
+      used: 0,
       total: response.data.tokens || 0
     };
   } catch (error) {

package/src/auth.js

@@ -1,5 +1,6 @@
 const http = require('http');
 const { URL } = require('url');
+const axios = require('axios');
 const chalk = require('chalk');
 const inquirer = require('inquirer');
 const { initializeApp } = require('firebase/app');
@@ -36,6 +37,10 @@ async function login() {
       console.log(chalk.gray('Login cancelled.'));
       return;
     }
+    // Clear old tokens
+    config.delete('authToken');
+    config.delete('refreshToken');
+    config.delete('tokenExpiry');
   }
 
   const { email } = await inquirer.prompt([{
@@ -86,13 +91,22 @@ async function login() {
       process.exit(1);
     }, 5 * 60 * 1000);
 
-    const token = await waitForAuth();
+    const authData = await waitForAuth();
     
     cleanup();
 
-    if (token) {
-      config.set('authToken', token);
+    if (authData && authData.token) {
+      // 🔥 Validate token format before storing
+      if (!authData.token.startsWith('eyJ')) {
+        throw new Error('Invalid token format received');
+      }
+
+      config.set('authToken', authData.token);
+      if (authData.refreshToken) {
+        config.set('refreshToken', authData.refreshToken);
+      }
       config.set('userEmail', email);
+      config.set('tokenExpiry', Date.now() + (55 * 60 * 1000)); // 55 minutes
       config.delete('pendingLogin');
       config.delete('pendingEmail');
       
@@ -100,10 +114,9 @@ async function login() {
       console.log(chalk.hex('#F24E1E')(`\n🎉 Welcome to OmniBioFex X, ${email}!`));
       console.log(chalk.gray('You can now use all CLI commands.\n'));
       
-      // 🔥 THE FIX: Exit the process cleanly
       process.exit(0);
     } else {
-      throw new Error('No token received');
+      throw new Error('No authentication data received');
     }
 
   } catch (error) {
@@ -135,7 +148,6 @@ function startLocalServer() {
   const server = http.createServer((req, res) => {
     const url = new URL(req.url, `http://localhost:${LOCAL_PORT}`);
     
-    // Ignore favicon requests
     if (url.pathname === '/favicon.ico') {
       res.writeHead(204);
       res.end();
@@ -145,11 +157,35 @@ function startLocalServer() {
     console.log('Local server received request:', req.url);
     
     if (url.pathname === CALLBACK_PATH) {
-      const token = url.searchParams.get('token');
+      // 🔥 FIX: Properly decode URL parameters
+      let token = url.searchParams.get('token');
+      let refreshToken = url.searchParams.get('refreshToken');
       const error = url.searchParams.get('error');
 
+      // 🔥 FIX: Replace spaces with + (URL decoding issue)
+      if (token && token.includes(' ')) {
+        console.log(chalk.yellow('⚠️  Token contains spaces, fixing...'));
+        token = token.replace(/ /g, '+');
+      }
+      
+      if (refreshToken && refreshToken.includes(' ')) {
+        refreshToken = refreshToken.replace(/ /g, '+');
+      }
+
       if (token) {
         console.log('✓ Received auth token from browser');
+        console.log('Token length:', token.length);
+        console.log('Token starts with:', token.substring(0, 20));
+        
+        // 🔥 Validate token format
+        if (!token.startsWith('eyJ')) {
+          console.error('✗ Invalid token format');
+          res.writeHead(400, { 'Content-Type': 'text/html' });
+          res.end('<h1>Invalid Token</h1><p>The authentication token is malformed.</p>');
+          global._authData = null;
+          return;
+        }
+        
         res.writeHead(200, { 'Content-Type': 'text/html' });
         res.end(`
           <!DOCTYPE html>
@@ -169,7 +205,6 @@ function startLocalServer() {
                        justify-content: center; margin: 0 auto 24px; }
               h1 { margin: 0 0 12px; font-size: 24px; }
               p { color: #737373; margin: 0 0 24px; }
-              .close { color: #F24E1E; font-size: 14px; font-family: monospace; }
             </style>
           </head>
           <body>
@@ -177,13 +212,12 @@ function startLocalServer() {
               <div class="check">✓</div>
               <h1>Authentication Successful!</h1>
               <p>You can close this window and return to your terminal.</p>
-              <div class="close">You may close this tab now.</div>
             </div>
           </body>
           </html>
         `);
         
-        global._authToken = token;
+        global._authData = { token, refreshToken };
       } else {
         console.error('✗ No token received, error:', error);
         res.writeHead(200, { 'Content-Type': 'text/html' });
@@ -203,12 +237,11 @@ function startLocalServer() {
             <div class="card">
               <h1>Authentication Failed</h1>
               <p>${error || 'Unknown error'}</p>
-              <p>Please close this window and try again in your terminal.</p>
             </div>
           </body>
           </html>
         `);
-        global._authToken = null;
+        global._authData = null;
       }
     } else {
       res.writeHead(404);
@@ -226,20 +259,64 @@ function startLocalServer() {
 function waitForAuth() {
   return new Promise((resolve) => {
     const checkInterval = setInterval(() => {
-      if (global._authToken !== undefined) {
+      if (global._authData !== undefined) {
         clearInterval(checkInterval);
-        const token = global._authToken;
-        delete global._authToken;
-        resolve(token);
+        const authData = global._authData;
+        delete global._authData;
+        resolve(authData);
       }
     }, 500);
   });
 }
 
+async function refreshAuthToken() {
+  const refreshToken = config.get('refreshToken');
+  
+  if (!refreshToken) {
+    throw new Error('No refresh token available. Please login again.');
+  }
+
+  try {
+    console.log(chalk.gray('🔄 Refreshing authentication token...'));
+    
+    const response = await axios.post(
+      `https://securetoken.googleapis.com/v1/token?key=${firebaseConfig.apiKey}`,
+      new URLSearchParams({
+        grant_type: 'refresh_token',
+        refresh_token: refreshToken
+      }).toString(),
+      {
+        headers: {
+          'Content-Type': 'application/x-www-form-urlencoded'
+        }
+      }
+    );
+
+    const { id_token, refresh_token, expires_in } = response.data;
+
+    // 🔥 Validate new token
+    if (!id_token || !id_token.startsWith('eyJ')) {
+      throw new Error('Invalid token received from refresh endpoint');
+    }
+
+    config.set('authToken', id_token);
+    config.set('refreshToken', refresh_token);
+    config.set('tokenExpiry', Date.now() + ((expires_in - 300) * 1000));
+
+    console.log(chalk.green('✓ Token refreshed successfully!'));
+    return id_token;
+  } catch (error) {
+    console.error(chalk.red('✗ Failed to refresh token:', error.message));
+    throw new Error('Token refresh failed. Please login again.');
+  }
+}
+
 function logout() {
   config.delete('authToken');
+  config.delete('refreshToken');
   config.delete('userId');
   config.delete('userEmail');
+  config.delete('tokenExpiry');
   console.log(chalk.green('✓ Logged out successfully'));
   process.exit(0);
 }
@@ -248,13 +325,36 @@ function isAuthenticated() {
   return config.get('authToken') !== null;
 }
 
-function getAuthToken() {
+function isTokenExpired() {
+  const expiry = config.get('tokenExpiry');
+  if (!expiry) return true;
+  return Date.now() >= expiry;
+}
+
+async function getAuthToken() {
+  if (isTokenExpired()) {
+    try {
+      await refreshAuthToken();
+    } catch (error) {
+      console.error(chalk.red(error.message));
+      process.exit(1);
+    }
+  }
+  
   const token = config.get('authToken');
   if (!token) {
     console.error(chalk.red('Not authenticated. Please run: obx login'));
     process.exit(1);
   }
+  
+  // 🔥 Validate token before returning
+  if (!token.startsWith('eyJ')) {
+    console.error(chalk.red('Stored token is corrupted. Please login again.'));
+    config.delete('authToken');
+    process.exit(1);
+  }
+  
   return token;
 }
 
-module.exports = { login, logout, isAuthenticated, getAuthToken };
+module.exports = { login, logout, isAuthenticated, getAuthToken, refreshAuthToken };

package/src/commands/debug.js

@@ -0,0 +1,37 @@
+const chalk = require('chalk');
+const config = require('../config');
+const { isAuthenticated } = require('../auth');
+
+async function debug() {
+  console.log(chalk.hex('#F24E1E')('\n🔍 Debug Information\n'));
+  
+  console.log(chalk.white('Authentication Status:'), isAuthenticated() ? chalk.green('✓ Logged in') : chalk.red('✗ Not logged in'));
+  console.log(chalk.white('User Email:'), config.get('userEmail') || 'Not set');
+  console.log(chalk.white('Token Expiry:'), config.get('tokenExpiry') ? new Date(config.get('tokenExpiry')).toLocaleString() : 'Not set');
+  
+  const token = config.get('authToken');
+  if (token) {
+    console.log(chalk.white('\nToken Info:'));
+    console.log(chalk.gray('  Length:'), token.length, 'characters');
+    console.log(chalk.gray('  Starts with:'), token.substring(0, 20));
+    console.log(chalk.gray('  Contains spaces:'), token.includes(' ') ? chalk.red('YES (CORRUPTED!)') : chalk.green('No'));
+    console.log(chalk.gray('  Contains +:'), token.includes('+') ? chalk.yellow('Yes') : chalk.green('No'));
+    console.log(chalk.gray('  Valid JWT format:'), token.startsWith('eyJ') ? chalk.green('Yes') : chalk.red('No'));
+    
+    // Check for corruption
+    if (token.includes(' ')) {
+      console.log(chalk.red('\n⚠️  TOKEN IS CORRUPTED! Contains spaces.'));
+      console.log(chalk.gray('This happens when + characters in JWT are converted to spaces during URL handling.'));
+      console.log(chalk.gray('Please login again with the fixed version.'));
+    }
+  } else {
+    console.log(chalk.yellow('\nNo token stored'));
+  }
+  
+  console.log(chalk.white('\nConfig File Location:'));
+  console.log(chalk.gray('  Windows: %APPDATA%\\omnibiofex\\config.json'));
+  console.log(chalk.gray('  macOS: ~/Library/Preferences/omnibiofex-nodejs/config.json'));
+  console.log(chalk.gray('  Linux: ~/.config/omnibiofex-nodejs/config.json'));
+}
+
+module.exports = { debug };

package/src/commands/research.js

@@ -1,7 +1,27 @@
 const chalk = require('chalk');
 const ora = require('ora');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
 const { createMission } = require('../api');
 const { isAuthenticated } = require('../auth');
+const { showThinking, displayReport, renderMarkdown } = require('../utils/display');
+
+// Create reports directory
+const REPORTS_DIR = path.join(os.homedir(), 'obx-reports');
+if (!fs.existsSync(REPORTS_DIR)) {
+  fs.mkdirSync(REPORTS_DIR, { recursive: true });
+}
+
+function saveReport(topic, content) {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const sanitizedTopic = topic.replace(/[^a-z0-9]/gi, '_').substring(0, 50);
+  const filename = `${sanitizedTopic}_${timestamp}.md`;
+  const filepath = path.join(REPORTS_DIR, filename);
+  
+  fs.writeFileSync(filepath, content, 'utf8');
+  return filepath;
+}
 
 async function literatureReview(topic) {
   if (!isAuthenticated()) {
@@ -9,15 +29,29 @@ async function literatureReview(topic) {
     return;
   }
 
+  // 🔥 Show thinking process
+  await showThinking('LITERATURE_REVIEW', topic);
+
   const spinner = ora(`Generating literature review for: ${topic}`).start();
 
   try {
-    const result = await createMission(topic, 'Academic', 'LITERATURE_REVIEW');
+    const result = await createMission(topic, 'LITERATURE_REVIEW');
     
     spinner.succeed(chalk.green('Literature review complete!'));
-    console.log(chalk.gray(`\nRCC Cost: ${result.rccCost}`));
-    console.log(chalk.gray(`Remaining Balance: ${result.rccBalance}`));
-    console.log(chalk.hex('#F24E1E')('\n✓ Report generated successfully.\n'));
+    
+    console.log(chalk.gray(`\n📊 Model: ${result.model}`));
+    console.log(chalk.gray(`💰 RCC Cost: ${result.rccCost}`));
+    console.log(chalk.gray(`💳 Remaining Balance: ${result.rccBalance} RCC`));
+    
+    // 🔥 Display the report with typing effect
+    await displayReport(result.response, true);
+    
+    console.log(chalk.hex('#F24E1E')('\n═══════════════════════════════════════════════════════════\n'));
+    
+    // Save to file
+    const filepath = saveReport(topic, result.response);
+    console.log(chalk.green(`✓ Report saved to: ${filepath}`));
+    console.log(chalk.gray('\nYou can now use all CLI commands.\n'));
     
   } catch (error) {
     spinner.fail(chalk.red('Failed to generate literature review'));
@@ -31,16 +65,28 @@ async function paper(file) {
     return;
   }
 
+  await showThinking('PAPER_ANALYSIS', file);
   const spinner = ora(`Analyzing paper: ${file}`).start();
 
   try {
-    // Would need file upload implementation
+    const result = await createMission(`Analyze this paper: ${file}`, 'PAPER_ANALYSIS');
+    
     spinner.succeed(chalk.green('Paper analysis complete!'));
-    console.log(chalk.gray('\n✓ Analysis generated successfully.\n'));
+    
+    console.log(chalk.gray(`\n📊 Model: ${result.model}`));
+    console.log(chalk.gray(`💰 RCC Cost: ${result.rccCost}`));
+    console.log(chalk.gray(`💳 Remaining Balance: ${result.rccBalance} RCC`));
+    
+    await displayReport(result.response, true);
+    
+    console.log(chalk.hex('#F24E1E')('\n═══════════════════════════════════════════════════════════\n'));
+    
+    const filepath = saveReport(file, result.response);
+    console.log(chalk.green(`✓ Report saved to: ${filepath}\n`));
     
   } catch (error) {
     spinner.fail(chalk.red('Failed to analyze paper'));
-    console.error(chalk.red(error.message));
+    console.error(chalk.red(error.response?.data?.error || error.message));
   }
 }
 
@@ -50,8 +96,29 @@ async function compare(files) {
     return;
   }
 
-  console.log(chalk.hex('#F24E1E')(`\n📊 Comparing ${files.length} papers\n`));
-  console.log(chalk.gray('Comparison complete!\n'));
+  await showThinking('COMPARE_PAPERS', files.join(', '));
+  const spinner = ora(`Comparing ${files.length} papers`).start();
+
+  try {
+    const result = await createMission(`Compare these papers: ${files.join(', ')}`, 'COMPARE_PAPERS');
+    
+    spinner.succeed(chalk.green('Paper comparison complete!'));
+    
+    console.log(chalk.gray(`\n📊 Model: ${result.model}`));
+    console.log(chalk.gray(`💰 RCC Cost: ${result.rccCost}`));
+    console.log(chalk.gray(`💳 Remaining Balance: ${result.rccBalance} RCC`));
+    
+    await displayReport(result.response, true);
+    
+    console.log(chalk.hex('#F24E1E')('\n═══════════════════════════════════════════════════════════\n'));
+    
+    const filepath = saveReport(`comparison_${files.length}papers`, result.response);
+    console.log(chalk.green(`✓ Report saved to: ${filepath}\n`));
+    
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to compare papers'));
+    console.error(chalk.red(error.response?.data?.error || error.message));
+  }
 }
 
 async function gaps(topic) {
@@ -60,15 +127,24 @@ async function gaps(topic) {
     return;
   }
 
+  await showThinking('RESEARCH_GAP', topic);
   const spinner = ora(`Discovering research gaps for: ${topic}`).start();
 
   try {
-    const result = await createMission(topic, 'Academic', 'RESEARCH_GAP');
+    const result = await createMission(topic, 'RESEARCH_GAP');
     
     spinner.succeed(chalk.green('Research gaps discovered!'));
-    console.log(chalk.gray(`\nRCC Cost: ${result.rccCost}`));
-    console.log(chalk.gray(`Remaining Balance: ${result.rccBalance}`));
-    console.log(chalk.hex('#F24E1E')('\n✓ Gap analysis complete.\n'));
+    
+    console.log(chalk.gray(`\n📊 Model: ${result.model}`));
+    console.log(chalk.gray(`💰 RCC Cost: ${result.rccCost}`));
+    console.log(chalk.gray(`💳 Remaining Balance: ${result.rccBalance} RCC`));
+    
+    await displayReport(result.response, true);
+    
+    console.log(chalk.hex('#F24E1E')('\n═══════════════════════════════════════════════════════════\n'));
+    
+    const filepath = saveReport(`gaps_${topic}`, result.response);
+    console.log(chalk.green(`✓ Report saved to: ${filepath}\n`));
     
   } catch (error) {
     spinner.fail(chalk.red('Failed to discover research gaps'));
@@ -82,15 +158,24 @@ async function hypothesis(topic) {
     return;
   }
 
+  await showThinking('HYPOTHESIS', topic);
   const spinner = ora(`Generating hypotheses for: ${topic}`).start();
 
   try {
-    const result = await createMission(topic, 'Academic', 'HYPOTHESIS');
+    const result = await createMission(topic, 'HYPOTHESIS');
     
     spinner.succeed(chalk.green('Hypotheses generated!'));
-    console.log(chalk.gray(`\nRCC Cost: ${result.rccCost}`));
-    console.log(chalk.gray(`Remaining Balance: ${result.rccBalance}`));
-    console.log(chalk.hex('#F24E1E')('\n✓ Hypothesis generation complete.\n'));
+    
+    console.log(chalk.gray(`\n📊 Model: ${result.model}`));
+    console.log(chalk.gray(`💰 RCC Cost: ${result.rccCost}`));
+    console.log(chalk.gray(`💳 Remaining Balance: ${result.rccBalance} RCC`));
+    
+    await displayReport(result.response, true);
+    
+    console.log(chalk.hex('#F24E1E')('\n═══════════════════════════════════════════════════════════\n'));
+    
+    const filepath = saveReport(`hypothesis_${topic}`, result.response);
+    console.log(chalk.green(`✓ Report saved to: ${filepath}\n`));
     
   } catch (error) {
     spinner.fail(chalk.red('Failed to generate hypotheses'));

package/src/config.js

@@ -6,7 +6,10 @@ const config = new Conf({
     apiUrl: 'https://obxvisionassistant-yyedhmslhq-uc.a.run.app',
     dashboardUrl: 'https://x.omnibiofex.cloud/dash',
     authToken: null,
+    refreshToken: null, // 🔥 NEW: Store refresh token
     userId: null,
+    userEmail: null,
+    tokenExpiry: null, // 🔥 NEW: Track token expiry time
   }
 });
 

package/src/utils/display.js

@@ -0,0 +1,226 @@
+const chalk = require('chalk');
+
+/**
+ * Simple markdown renderer using chalk
+ * Handles: **bold**, *italic*, # headings, - lists, `code`, tables
+ */
+function renderMarkdown(markdown) {
+  const lines = markdown.split('\n');
+  const rendered = [];
+  
+  for (let i = 0; i < lines.length; i++) {
+    let line = lines[i];
+    
+    // Skip empty lines
+    if (line.trim() === '') {
+      rendered.push('');
+      continue;
+    }
+    
+    // Headings
+    if (line.startsWith('### ')) {
+      rendered.push(chalk.hex('#F24E1E').bold('\n' + line.substring(4)));
+      continue;
+    }
+    if (line.startsWith('## ')) {
+      rendered.push(chalk.hex('#F24E1E').bold.underline('\n' + line.substring(3)));
+      continue;
+    }
+    if (line.startsWith('# ')) {
+      rendered.push(chalk.hex('#F24E1E').bold.underline('\n' + line.substring(2)));
+      continue;
+    }
+    
+    // Horizontal rules
+    if (line.trim() === '---' || line.trim() === '***') {
+      rendered.push(chalk.gray('─'.repeat(60)));
+      continue;
+    }
+    
+    // List items
+    if (line.trim().startsWith('- ') || line.trim().startsWith('* ')) {
+      const content = line.trim().substring(2);
+      const formatted = formatInlineMarkdown(content);
+      rendered.push(`  ${chalk.hex('#F24E1E')('▸')} ${formatted}`);
+      continue;
+    }
+    
+    // Numbered lists
+    const numberedMatch = line.match(/^(\d+)\.\s+(.+)/);
+    if (numberedMatch) {
+      const num = numberedMatch[1];
+      const content = numberedMatch[2];
+      const formatted = formatInlineMarkdown(content);
+      rendered.push(`  ${chalk.hex('#F24E1E')(num + '.')} ${formatted}`);
+      continue;
+    }
+    
+    // Table rows (simple rendering)
+    if (line.includes('|') && line.trim().startsWith('|')) {
+      // Skip separator rows like |---|---|
+      if (line.match(/^\|[\s\-:]+\|$/)) {
+        continue;
+      }
+      const cells = line.split('|').filter(cell => cell.trim() !== '');
+      const formattedCells = cells.map(cell => {
+        const trimmed = cell.trim();
+        return formatInlineMarkdown(trimmed);
+      });
+      rendered.push('  ' + formattedCells.join('  │  '));
+      continue;
+    }
+    
+    // Regular text with inline formatting
+    rendered.push(formatInlineMarkdown(line));
+  }
+  
+  return rendered.join('\n');
+}
+
+/**
+ * Format inline markdown: **bold**, *italic*, `code`, [links]
+ */
+function formatInlineMarkdown(text) {
+  let result = text;
+  
+  // Bold: **text** or __text__
+  result = result.replace(/\*\*(.+?)\*\*/g, chalk.bold.white('$1'));
+  result = result.replace(/__(.+?)__/g, chalk.bold.white('$1'));
+  
+  // Italic: *text* or _text_
+  result = result.replace(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, chalk.italic('$1'));
+  result = result.replace(/(?<!_)_(?!_)(.+?)(?<!_)_(?!_)/g, chalk.italic('$1'));
+  
+  // Inline code: `code`
+  result = result.replace(/`([^`]+)`/g, chalk.bgBlack.cyan(' $1 '));
+  
+  // Links: [text](url)
+  result = result.replace(/\[([^\]]+)\]\(([^)]+)\)/g, chalk.blue.underline('$1'));
+  
+  return result;
+}
+
+/**
+ * Typing effect - displays text character by character
+ */
+async function typeText(text, speed = 8) {
+  for (const char of text) {
+    process.stdout.write(char);
+    await new Promise(resolve => setTimeout(resolve, speed));
+  }
+}
+
+/**
+ * Streaming effect - displays text in chunks (faster than char-by-char)
+ */
+async function streamText(text, chunkSize = 3, delay = 15) {
+  for (let i = 0; i < text.length; i += chunkSize) {
+    process.stdout.write(text.substring(i, i + chunkSize));
+    await new Promise(resolve => setTimeout(resolve, delay));
+  }
+}
+
+/**
+ * Shows animated thinking process with multi-agent swarm
+ */
+async function showThinking(taskType, topic) {
+  const thinkingSteps = getThinkingSteps(taskType, topic);
+  
+  console.log(chalk.hex('#F24E1E')('\n🧠 OmniBioFex X is thinking...\n'));
+  
+  for (const step of thinkingSteps) {
+    const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    let frameIndex = 0;
+    
+    const spinner = setInterval(() => {
+      process.stdout.write(`\r  ${chalk.hex('#F24E1E')(frames[frameIndex])} ${chalk.gray(step.text)}`);
+      frameIndex = (frameIndex + 1) % frames.length;
+    }, 80);
+    
+    await new Promise(resolve => setTimeout(resolve, step.duration));
+    
+    clearInterval(spinner);
+    process.stdout.write('\r');
+    console.log(`  ${chalk.green('✓')} ${step.text}`);
+  }
+  
+  console.log(chalk.hex('#F24E1E')('\n✨ Synthesis complete!\n'));
+  console.log(chalk.hex('#F24E1E')('═══════════════════════════════════════════════════════════\n'));
+}
+
+/**
+ * Get thinking steps based on task type
+ */
+function getThinkingSteps(taskType, topic) {
+  const baseSteps = [
+    { text: `🔍 Analyzing research query: "${topic.substring(0, 40)}${topic.length > 40 ? '...' : ''}"`, duration: 600 },
+    { text: '🌐 Connecting to Deep Reasoning Engine™...', duration: 400 },
+  ];
+
+  const taskSpecificSteps = {
+    LITERATURE_REVIEW: [
+      { text: '📚 Literature Agent: Scanning academic databases...', duration: 800 },
+      { text: '📖 Reading and extracting key findings from 200+ papers...', duration: 1000 },
+      { text: '🔗 Mapping citation networks and research lineage...', duration: 700 },
+      { text: '📊 Statistician: Validating methodology quality...', duration: 600 },
+      { text: '🔎 Critic: Identifying contradictions and gaps...', duration: 700 },
+      { text: '✍️  Writer: Synthesizing comprehensive review...', duration: 800 },
+    ],
+    RESEARCH_GAP: [
+      { text: '📚 Literature Agent: Surveying existing research...', duration: 800 },
+      { text: '🗺️  Domain Expert: Mapping research landscape...', duration: 700 },
+      { text: '🔍 Identifying underexplored areas...', duration: 900 },
+      { text: '📊 Statistician: Analyzing sample size distributions...', duration: 600 },
+      { text: '💡 Generating novel research opportunities...', duration: 800 },
+    ],
+    HYPOTHESIS: [
+      { text: '📚 Literature Agent: Reviewing theoretical foundations...', duration: 800 },
+      { text: '🧠 Domain Expert: Applying domain knowledge...', duration: 700 },
+      { text: '🔎 Critic: Stress-testing initial hypotheses...', duration: 800 },
+      { text: '📊 Statistician: Designing validation approaches...', duration: 600 },
+      { text: '💡 Generating testable hypotheses with rationale...', duration: 700 },
+    ],
+    COMPARE_PAPERS: [
+      { text: '📚 Literature Agent: Extracting methodologies...', duration: 700 },
+      { text: '🔍 Comparing frameworks and approaches...', duration: 800 },
+      { text: '📊 Statistician: Analyzing result differences...', duration: 600 },
+      { text: '🔎 Critic: Evaluating strengths and weaknesses...', duration: 700 },
+      { text: '✍️  Writer: Synthesizing comparison matrix...', duration: 600 },
+    ],
+    PAPER_ANALYSIS: [
+      { text: '📄 Parsing document structure and content...', duration: 600 },
+      { text: '🔍 Extracting key claims and evidence...', duration: 700 },
+      { text: '📊 Statistician: Evaluating methodology...', duration: 700 },
+      { text: '🔎 Critic: Identifying limitations...', duration: 600 },
+      { text: '✍️  Writer: Generating structured analysis...', duration: 600 },
+    ],
+  };
+
+  const specificSteps = taskSpecificSteps[taskType] || taskSpecificSteps.LITERATURE_REVIEW;
+  
+  return [...baseSteps, ...specificSteps];
+}
+
+/**
+ * Display a complete research report with typing effect
+ */
+async function displayReport(markdown, useTypingEffect = true) {
+  const rendered = renderMarkdown(markdown);
+  
+  if (useTypingEffect) {
+    const lines = rendered.split('\n');
+    for (const line of lines) {
+      await streamText(line + '\n', 5, 10);
+    }
+  } else {
+    console.log(rendered);
+  }
+}
+
+module.exports = {
+  typeText,
+  streamText,
+  showThinking,
+  renderMarkdown,
+  displayReport,
+};