@banaxi/banana-code 1.0.4 → 1.1.0

package/src/providers/ollama.js

@@ -1,18 +1,33 @@
-import { TOOLS, executeTool } from '../tools/registry.js';
+import { getAvailableTools, executeTool } from '../tools/registry.js';
 import chalk from 'chalk';
 import ora from 'ora';
 import { getSystemPrompt } from '../prompt.js';
-
-const SYSTEM_PROMPT = getSystemPrompt();
+import { printMarkdown } from '../utils/markdown.js';
 
 export class OllamaProvider {
     constructor(config) {
+        this.config = config;
         this.modelName = config.model || 'llama3';
-        this.messages = [{ role: 'system', content: SYSTEM_PROMPT }];
-        this.tools = TOOLS.map(t => ({ type: 'function', function: t }));
+        this.systemPrompt = getSystemPrompt(config);
+        this.messages = [{ role: 'system', content: this.systemPrompt }];
+        this.tools = getAvailableTools(config).map(t => ({
+            type: 'function',
+            function: {
+                name: t.name,
+                description: t.description,
+                parameters: t.parameters
+            }
+        }));
         this.URL = 'http://localhost:11434/api/chat';
     }
 
+    updateSystemPrompt(newPrompt) {
+        this.systemPrompt = newPrompt;
+        if (this.messages.length > 0 && this.messages[0].role === 'system') {
+            this.messages[0].content = newPrompt;
+        }
+    }
+
     async sendMessage(message) {
         this.messages.push({ role: 'user', content: message });
 
@@ -42,7 +57,11 @@ export class OllamaProvider {
                 const messageObj = data.message;
 
                 if (messageObj.content) {
-                    process.stdout.write(chalk.cyan(messageObj.content));
+                    if (this.config.useMarkedTerminal) {
+                        printMarkdown(messageObj.content);
+                    } else {
+                        process.stdout.write(chalk.cyan(messageObj.content));
+                    }
                     finalResponse += messageObj.content;
                 }
 
@@ -58,6 +77,9 @@ export class OllamaProvider {
                     console.log(chalk.yellow(`\n[Banana Calling Tool: ${fn.name}]`));
 
                     let res = await executeTool(fn.name, fn.arguments);
+                    if (this.config.debug) {
+                        console.log(chalk.gray(`[DEBUG] Tool Result: ${typeof res === 'string' ? res : JSON.stringify(res, null, 2)}`));
+                    }
                     console.log(chalk.yellow(`[Tool Result Received]\n`));
 
                     this.messages.push({

package/src/providers/ollamaCloud.js

@@ -0,0 +1,107 @@
+import { getAvailableTools, executeTool } from '../tools/registry.js';
+import chalk from 'chalk';
+import ora from 'ora';
+import { getSystemPrompt } from '../prompt.js';
+import { printMarkdown } from '../utils/markdown.js';
+
+export class OllamaCloudProvider {
+    constructor(config) {
+        this.config = config;
+        this.apiKey = config.apiKey;
+        this.modelName = config.model || 'llama3.3';
+        this.systemPrompt = getSystemPrompt(config);
+        this.messages = [{ role: 'system', content: this.systemPrompt }];
+        this.tools = getAvailableTools(config).map(t => ({
+            type: 'function',
+            function: {
+                name: t.name,
+                description: t.description,
+                parameters: t.parameters
+            }
+        }));
+        this.URL = 'https://ollama.com/api/chat';
+    }
+
+    updateSystemPrompt(newPrompt) {
+        this.systemPrompt = newPrompt;
+        if (this.messages.length > 0 && this.messages[0].role === 'system') {
+            this.messages[0].content = newPrompt;
+        }
+    }
+
+    async sendMessage(message) {
+        this.messages.push({ role: 'user', content: message });
+
+        let spinner = ora({ text: 'Thinking (Cloud)...', color: 'yellow', stream: process.stdout }).start();
+        let finalResponse = '';
+
+        try {
+            while (true) {
+                const response = await fetch(this.URL, {
+                    method: 'POST',
+                    headers: { 
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${this.apiKey}`
+                    },
+                    body: JSON.stringify({
+                        model: this.modelName,
+                        messages: this.messages,
+                        tools: this.tools.length > 0 ? this.tools : undefined,
+                        stream: false // Cloud API sometimes prefers non-streaming or different SSE formats
+                    })
+                });
+
+                if (!response.ok) {
+                    const errorText = await response.text();
+                    spinner.stop();
+                    throw new Error(`HTTP ${response.status}: ${errorText}`);
+                }
+
+                const data = await response.json();
+                spinner.stop();
+
+                const messageObj = data.message;
+
+                if (messageObj.content) {
+                    if (this.config.useMarkedTerminal) {
+                        printMarkdown(messageObj.content);
+                    } else {
+                        process.stdout.write(chalk.cyan(messageObj.content));
+                    }
+                    finalResponse += messageObj.content;
+                }
+
+                this.messages.push(messageObj);
+
+                if (!messageObj.tool_calls || messageObj.tool_calls.length === 0) {
+                    console.log();
+                    break;
+                }
+
+                for (const call of messageObj.tool_calls) {
+                    const fn = call.function;
+                    console.log(chalk.yellow(`\n[Banana Calling Tool: ${fn.name}]`));
+
+                    let res = await executeTool(fn.name, fn.arguments);
+                    if (this.config.debug) {
+                        console.log(chalk.gray(`[DEBUG] Tool Result: ${typeof res === 'string' ? res : JSON.stringify(res, null, 2)}`));
+                    }
+                    console.log(chalk.yellow(`[Tool Result Received]\n`));
+
+                    this.messages.push({
+                        role: 'tool',
+                        content: typeof res === 'string' ? res : JSON.stringify(res)
+                    });
+                }
+
+                spinner = ora({ text: 'Processing tool results...', color: 'yellow', stream: process.stdout }).start();
+            }
+
+            return finalResponse;
+        } catch (err) {
+            if (spinner.isSpinning) spinner.stop();
+            console.error(chalk.red(`Ollama Cloud Error: ${err.message}`));
+            return `Error: ${err.message}`;
+        }
+    }
+}

package/src/providers/openai.js

@@ -1,13 +1,12 @@
 import OpenAI from 'openai';
-import { TOOLS, executeTool } from '../tools/registry.js';
+import { getAvailableTools, executeTool } from '../tools/registry.js';
 import chalk from 'chalk';
 import ora from 'ora';
 import os from 'os';
 import path from 'path';
 import fsSync from 'fs';
 import { getSystemPrompt } from '../prompt.js';
-
-const SYSTEM_PROMPT = getSystemPrompt();
+import { printMarkdown } from '../utils/markdown.js';
 
 export class OpenAIProvider {
     constructor(config) {
@@ -16,8 +15,23 @@ export class OpenAIProvider {
             this.openai = new OpenAI({ apiKey: config.apiKey });
         }
         this.modelName = config.model || 'gpt-4o';
-        this.messages = [{ role: 'system', content: SYSTEM_PROMPT }];
-        this.tools = TOOLS.map(t => ({ type: 'function', function: t }));
+        this.systemPrompt = getSystemPrompt(config);
+        this.messages = [{ role: 'system', content: this.systemPrompt }];
+        this.tools = getAvailableTools(config).map(t => ({
+            type: 'function',
+            function: {
+                name: t.name,
+                description: t.description,
+                parameters: t.parameters
+            }
+        }));
+    }
+
+    updateSystemPrompt(newPrompt) {
+        this.systemPrompt = newPrompt;
+        if (this.messages.length > 0 && this.messages[0].role === 'system') {
+            this.messages[0].content = newPrompt;
+        }
     }
 
     async sendMessage(message) {
@@ -53,8 +67,10 @@ export class OpenAIProvider {
                     const delta = chunk.choices[0]?.delta;
 
                     if (delta?.content) {
-                        if (spinner.isSpinning) spinner.stop();
-                        process.stdout.write(chalk.cyan(delta.content));
+                        if (spinner.isSpinning && !this.config.useMarkedTerminal) spinner.stop();
+                        if (!this.config.useMarkedTerminal) {
+                            process.stdout.write(chalk.cyan(delta.content));
+                        }
                         chunkResponse += delta.content;
                         finalResponse += delta.content;
                     }
@@ -81,6 +97,7 @@ export class OpenAIProvider {
                 if (spinner.isSpinning) spinner.stop();
 
                 if (chunkResponse) {
+                    if (this.config.useMarkedTerminal) printMarkdown(chunkResponse);
                     this.messages.push({ role: 'assistant', content: chunkResponse });
                 }
 
@@ -105,6 +122,9 @@ export class OpenAIProvider {
                     } catch (e) { }
 
                     const res = await executeTool(call.function.name, args);
+                    if (this.config.debug) {
+                        console.log(chalk.gray(`[DEBUG] Tool Result: ${typeof res === 'string' ? res : JSON.stringify(res, null, 2)}`));
+                    }
                     console.log(chalk.yellow(`[Tool Result Received]\n`));
 
                     this.messages.push({
@@ -197,6 +217,18 @@ export class OpenAIProvider {
                 const backendInput = mapMessagesToBackend(this.messages);
                 const backendTools = mapToolsToBackend(this.tools);
 
+                const payload = {
+                    model: this.modelName || 'gpt-5.1-codex',
+                    instructions: this.systemPrompt,
+                    input: backendInput,
+                    tools: backendTools,
+                    store: false,
+                    stream: true,
+                    include: ["reasoning.encrypted_content"],
+                    reasoning: { effort: "medium", summary: "auto" },
+                    text: { verbosity: "medium" }
+                };
+
                 const response = await fetch('https://chatgpt.com/backend-api/codex/responses', {
                     method: 'POST',
                     headers: {
@@ -207,17 +239,7 @@ export class OpenAIProvider {
                         'originator': 'codex_cli_rs',
                         'Accept': 'text/event-stream'
                     },
-                    body: JSON.stringify({
-                        model: this.modelName || 'gpt-5.1-codex',
-                        instructions: SYSTEM_PROMPT,
-                        input: backendInput,
-                        tools: backendTools,
-                        store: false,
-                        stream: true,
-                        include: ["reasoning.encrypted_content"],
-                        reasoning: { effort: "medium", summary: "auto" },
-                        text: { verbosity: "medium" }
-                    })
+                    body: JSON.stringify(payload)
                 });
 
                 if (!response.ok) {
@@ -250,10 +272,17 @@ export class OpenAIProvider {
                                 try {
                                     const data = JSON.parse(currentDataBuffer);
                                     if (currentEvent === 'response.output_text.delta') {
-                                        if (spinner && spinner.isSpinning) spinner.stop();
-                                        process.stdout.write(chalk.cyan(data.delta));
+                                        if (spinner && spinner.isSpinning && !this.config.useMarkedTerminal) spinner.stop();
+                                        if (!this.config.useMarkedTerminal) {
+                                            process.stdout.write(chalk.cyan(data.delta));
+                                        }
                                         currentChunkResponse += data.delta;
                                         finalResponse += data.delta;
+                                    } else if (currentEvent === 'response.reasoning.delta' || currentEvent === 'response.reasoning_text.delta' || currentEvent.includes('reasoning.delta')) {
+                                        if (this.config.debug && data.delta) {
+                                            if (spinner && spinner.isSpinning) spinner.stop();
+                                            process.stdout.write(chalk.gray(data.delta));
+                                        }
                                     } else if (currentEvent === 'response.output_item.added' && data.item?.type === 'function_call') {
                                         if (spinner && spinner.isSpinning) spinner.stop();
                                         currentToolCall = {
@@ -267,7 +296,7 @@ export class OpenAIProvider {
                                         if (!spinner.isSpinning) {
                                             spinner = ora({ text: `Generating ${chalk.yellow(currentToolCall.name)} (${currentToolCall.arguments.length} bytes)...`, color: 'yellow', stream: process.stdout }).start();
                                         } else {
-                                            spinner.text = `Generating ${chalk.yellow(currentToolCall.name)} (${currentToolCall.arguments.length} bytes)...`;
+                                            spinner.text = `Generating ${chalk.yellow(currentToolCall.name)} arguments (${currentToolCall.arguments.length} bytes)...`;
                                         }
                                     } else if (currentEvent === 'response.output_item.done' && data.item?.type === 'function_call' && currentToolCall) {
                                         if (spinner && spinner.isSpinning) spinner.stop();
@@ -313,7 +342,6 @@ export class OpenAIProvider {
                                 currentChunkResponse += data.delta;
                                 finalResponse += data.delta;
                             }
-                            // Note: tool calls usually don't end exactly at stream end without \n\n
                         } catch (e) { }
                     }
                 }
@@ -321,6 +349,7 @@ export class OpenAIProvider {
                 if (spinner.isSpinning) spinner.stop();
 
                 if (currentChunkResponse) {
+                    if (this.config.useMarkedTerminal) printMarkdown(currentChunkResponse);
                     this.messages.push({ role: 'assistant', content: currentChunkResponse });
                 }
 
@@ -343,6 +372,9 @@ export class OpenAIProvider {
                     } catch (e) { }
 
                     const res = await executeTool(call.function.name, args);
+                    if (this.config.debug) {
+                        console.log(chalk.gray(`[DEBUG] Tool Result: ${typeof res === 'string' ? res : JSON.stringify(res, null, 2)}`));
+                    }
                     console.log(chalk.yellow(`[Tool Result Received]\n`));
 
                     this.messages.push({

package/src/tools/duckDuckGo.js

@@ -0,0 +1,34 @@
+import ora from 'ora';
+import chalk from 'chalk';
+
+export async function duckDuckGo({ query }) {
+    const url = `https://api.duckduckgo.com/?q=${encodeURIComponent(query)}&format=json&pretty=1`;
+    const spinner = ora({ text: `Searching DuckDuckGo for ${chalk.cyan(query)}...`, color: 'yellow', stream: process.stdout }).start();
+
+    try {
+        const res = await fetch(url);
+        const data = await res.json();
+        if (spinner.isSpinning) spinner.stop();
+
+        // DuckDuckGo API returns a lot of fields, let's extract the most useful ones
+        const result = {
+            Abstract: data.Abstract,
+            AbstractText: data.AbstractText,
+            AbstractSource: data.AbstractSource,
+            AbstractURL: data.AbstractURL,
+            Answer: data.Answer,
+            Definition: data.Definition,
+            DefinitionSource: data.DefinitionSource,
+            DefinitionURL: data.DefinitionURL,
+            RelatedTopics: data.RelatedTopics?.slice(0, 5).map(topic => ({
+                Text: topic.Text,
+                FirstURL: topic.FirstURL
+            }))
+        };
+
+        return JSON.stringify(result, null, 2);
+    } catch (err) {
+        if (spinner.isSpinning) spinner.stop();
+        return `Error searching DuckDuckGo: ${err.message}`;
+    }
+}

package/src/tools/duckDuckGoScrape.js

@@ -0,0 +1,93 @@
+import chalk from 'chalk';
+import ora from 'ora';
+
+export async function duckDuckGoScrape({ query }) {
+    const url = `https://duckduckgo.com/lite/?q=${encodeURIComponent(query)}`;
+    const userAgent = 'BananaCode/1.0 (AI-Agent)';
+    
+    const spinner = ora({ text: `Scraping DuckDuckGo Lite for ${chalk.cyan(query)}...`, color: 'yellow', stream: process.stdout }).start();
+
+    try {
+        const res = await fetch(url, {
+            headers: {
+                'User-Agent': userAgent
+            }
+        });
+
+        if (res.status === 403 || res.status === 429) {
+            if (spinner.isSpinning) spinner.stop();
+            return "ERROR: We are currently Rate Limited by DuckDuckGo. Please try again later or use the Quick Answer tool.";
+        }
+
+        if (!res.ok) {
+            if (spinner.isSpinning) spinner.stop();
+            return `Error: DuckDuckGo returned HTTP ${res.status}`;
+        }
+
+        const html = await res.text();
+        if (spinner.isSpinning) spinner.stop();
+
+        // Basic "scraping" using regex since we don't have a full DOM parser like JSDOM here
+        // DuckDuckGo Lite results are usually in <a class="result-link" href="...">...</a>
+        // and have a titles in them.
+        
+        const results = [];
+        // More flexible regex to find result-link tags
+        const tagRegex = /<a\s+[^>]*class=['"]result-link['"][^>]*>([\s\S]*?)<\/a>/gi;
+        
+        let match;
+        while ((match = tagRegex.exec(html)) !== null) {
+            const fullTag = match[0];
+            const title = match[1].replace(/<[^>]*>/g, '').trim();
+            const hrefMatch = /href=['"]([^'"]+)['"]/i.exec(fullTag);
+            
+            if (hrefMatch) {
+                let link = hrefMatch[1];
+
+                // Extract the actual URL from the uddg parameter if present
+                if (link.includes('uddg=')) {
+                    // Extract using manual split if URLSearchParams is finicky with partials
+                    const uddgPart = link.split('uddg=')[1]?.split('&')[0];
+                    if (uddgPart) {
+                        try {
+                            link = decodeURIComponent(uddgPart);
+                        } catch (e) { }
+                    }
+                }
+                
+                // Ensure link is absolute
+                if (link.startsWith('//')) {
+                    link = 'https:' + link;
+                } else if (link.startsWith('/')) {
+                    link = 'https://duckduckgo.com' + link;
+                }
+
+                results.push({ title, link });
+            }
+        }
+
+        if (results.length === 0) {
+            // Try alternative regex if the first one fails (lite structure can change)
+            const altRegex = /<a[^>]+href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/g;
+            let altMatch;
+            let count = 0;
+            while ((altMatch = altRegex.exec(html)) !== null && count < 10) {
+                const link = altMatch[1];
+                if (link.startsWith('http') && !link.includes('duckduckgo.com')) {
+                    const title = altMatch[2].replace(/<[^>]*>/g, '').trim();
+                    results.push({ title, link });
+                    count++;
+                }
+            }
+        }
+
+        if (results.length === 0) {
+            return "No results found on DuckDuckGo Lite.";
+        }
+
+        return JSON.stringify(results.slice(0, 10), null, 2);
+    } catch (err) {
+        if (spinner.isSpinning) spinner.stop();
+        return `Error scraping DuckDuckGo: ${err.message}`;
+    }
+}

package/src/tools/execCommand.js

@@ -29,12 +29,16 @@ export async function execCommand({ command, cwd = process.cwd() }) {
 
         child.on('close', (code) => {
             if (spinner.isSpinning) spinner.stop();
-            resolve(`Command exited with code ${code}.\nOutput:\n${output}`);
+            let result = `Command exited with code ${code}.\nOutput:\n${output}`;
+            if (code !== 0) {
+                result += `\n\n[System Note: The command failed with an error. Please analyze the output above and try to fix the issue if it is possible.]`;
+            }
+            resolve(result);
         });
 
         child.on('error', (err) => {
             if (spinner.isSpinning) spinner.stop();
-            resolve(`Error executing command: ${err.message}`);
+            resolve(`Error executing command: ${err.message}\n\n[System Note: The command failed to execute. Please analyze the error and try to fix the issue if it is possible.]`);
         });
     });
 }

package/src/tools/patchFile.js

@@ -0,0 +1,63 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { requestPermission } from '../permissions.js';
+import * as diff from 'diff';
+import chalk from 'chalk';
+
+export async function patchFile({ filepath, edits }) {
+    const absPath = path.resolve(process.cwd(), filepath);
+    
+    let content = '';
+    try {
+        content = await fs.readFile(absPath, 'utf8');
+    } catch (err) {
+        return `Error reading file: ${err.message}`;
+    }
+
+    const originalContent = content;
+
+    for (let i = 0; i < edits.length; i++) {
+        const { oldText, newText, occurrence = 1 } = edits[i];
+        
+        if (!content.includes(oldText)) {
+            return `Edit ${i + 1} failed: Cannot find the exact text to replace in ${filepath}. Please ensure you provide the exact text including whitespace and indentation.`;
+        }
+
+        if (occurrence === 0) {
+            content = content.split(oldText).join(newText);
+        } else {
+            let index = -1;
+            for (let j = 0; j < occurrence; j++) {
+                index = content.indexOf(oldText, index + 1);
+                if (index === -1) {
+                    return `Edit ${i + 1} failed: Cannot find occurrence ${occurrence} of the text to replace in ${filepath}.`;
+                }
+            }
+            content = content.substring(0, index) + newText + content.substring(index + oldText.length);
+        }
+    }
+
+    if (originalContent === content) {
+        return `No changes were made. The file is identical to the requested edit.`;
+    }
+
+    const patch = diff.createPatch(filepath, originalContent, content);
+
+    console.log(chalk.cyan(`\nPreviewing changes for ${filepath}:`));
+    patch.split('\n').filter(l => l.length > 0 && !l.startsWith('===') && !l.startsWith('---') && !l.startsWith('+++')).forEach(line => {
+        if (line.startsWith('+')) console.log(chalk.green(line));
+        else if (line.startsWith('-')) console.log(chalk.red(line));
+        else console.log(chalk.gray(line));
+    });
+    console.log('');
+
+    const perm = await requestPermission('Patch File', filepath);
+    if (!perm.allowed) return `User denied permission to patch: ${filepath}`;
+
+    try {
+        await fs.writeFile(absPath, content, 'utf8');
+        return `Successfully patched ${filepath}`;
+    } catch (err) {
+        return `Error writing file: ${err.message}`;
+    }
+}

package/src/tools/registry.js

@@ -4,6 +4,9 @@ import { writeFile } from './writeFile.js';
 import { fetchUrl } from './fetchUrl.js';
 import { searchFiles } from './searchFiles.js';
 import { listDirectory } from './listDirectory.js';
+import { duckDuckGo } from './duckDuckGo.js';
+import { duckDuckGoScrape } from './duckDuckGoScrape.js';
+import { patchFile } from './patchFile.js';
 
 export const TOOLS = [
     {
@@ -74,9 +77,74 @@ export const TOOLS = [
             },
             required: ['directoryPath']
         }
+    },
+    {
+        name: 'duck_duck_go',
+        label: 'DuckDuckGo Quick Answer',
+        description: 'Search for quick answers using DuckDuckGo API.',
+        beta: true,
+        parameters: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'The search query' }
+            },
+            required: ['query']
+        }
+    },
+    {
+        name: 'duck_duck_go_scrape',
+        label: 'DuckDuckGo Scrape (Lite)',
+        description: 'Perform a full search on DuckDuckGo Lite and extract result links.',
+        beta: true,
+        parameters: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'The search query' }
+            },
+            required: ['query']
+        }
+    },
+    {
+        name: 'patch_file',
+        label: 'Surgical File Patch (Beta)',
+        description: 'Edit a file by replacing specific sections of text. Much more efficient for large files.',
+        beta: true,
+        parameters: {
+            type: 'object',
+            properties: {
+                filepath: { type: 'string', description: 'Path to the file to patch' },
+                edits: {
+                    type: 'array',
+                    description: 'List of edits to perform in order',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            oldText: { type: 'string', description: 'The exact text to find (including whitespace/indentation)' },
+                            newText: { type: 'string', description: 'The text to replace it with' },
+                            occurrence: { 
+                                type: 'integer', 
+                                description: 'Which occurrence of oldText to replace (1-based). Use 0 to replace all occurrences.',
+                                default: 1 
+                            }
+                        },
+                        required: ['oldText', 'newText']
+                    }
+                }
+            },
+            required: ['filepath', 'edits']
+        }
     }
 ];
 
+export function getAvailableTools(config = {}) {
+    return TOOLS.filter(tool => {
+        if (tool.beta) {
+            return config.betaTools && config.betaTools.includes(tool.name);
+        }
+        return true;
+    });
+}
+
 export async function executeTool(name, args) {
     switch (name) {
         case 'execute_command': return await execCommand(args);
@@ -85,6 +153,9 @@ export async function executeTool(name, args) {
         case 'fetch_url': return await fetchUrl(args);
         case 'search_files': return await searchFiles(args);
         case 'list_directory': return await listDirectory(args);
+        case 'duck_duck_go': return await duckDuckGo(args);
+        case 'duck_duck_go_scrape': return await duckDuckGoScrape(args);
+        case 'patch_file': return await patchFile(args);
         default: return `Unknown tool: ${name}`;
     }
 }

package/src/utils/markdown.js

@@ -0,0 +1,21 @@
+import { marked } from 'marked';
+import { markedTerminal } from 'marked-terminal';
+import chalk from 'chalk';
+
+marked.use(markedTerminal({
+    // Prominent headings
+    firstHeading: chalk.magenta.bold.underline,
+    heading: chalk.magenta.bold,
+    
+    // Stronger emphasis for other elements
+    strong: chalk.yellow.bold,
+    em: chalk.italic,
+    codespan: chalk.bgRgb(40, 40, 40).yellow,
+    
+    // Custom tab/padding
+    tab: 4
+}));
+
+export function printMarkdown(text) {
+    process.stdout.write(marked.parse(text));
+}