natureco-cli 2.23.28 → 2.23.30

package/src/commands/workboard.js

@@ -0,0 +1,207 @@
+const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { getConfig, saveConfig } = require('../utils/config');
+
+const BOARD_FILE = path.join(os.homedir(), '.natureco', 'data', 'workboard.json');
+
+function loadBoard() {
+  try {
+    if (fs.existsSync(BOARD_FILE)) {
+      return JSON.parse(fs.readFileSync(BOARD_FILE, 'utf8'));
+    }
+  } catch {}
+  return { columns: ['todo', 'in-progress', 'done'], items: [] };
+}
+
+function saveBoard(board) {
+  const dir = path.dirname(BOARD_FILE);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(BOARD_FILE, JSON.stringify(board, null, 2));
+}
+
+function workboard(args) {
+  const [action, ...params] = args || [];
+
+  if (!action || action === 'show') return showBoard();
+  if (action === 'add') return addItem(params.join(' '));
+  if (action === 'move') return moveItem(params[0], params[1]);
+  if (action === 'remove') return removeItem(params[0]);
+  if (action === 'clear') return clearBoard();
+  if (action === 'columns') return manageColumns(params);
+  if (action === 'export') return exportBoard();
+  if (action === 'import') return importBoard(params[0]);
+
+  console.log(chalk.red(`\n  ❌ Bilinmeyen komut: ${action}\n`));
+  console.log(chalk.gray('  Kullanım: natureco workboard [show|add|move|remove|clear|columns|export|import]\n'));
+  process.exit(1);
+}
+
+function showBoard() {
+  const board = loadBoard();
+  const config = getConfig();
+  const wbConfig = config.workboard || {};
+  const columns = wbConfig.columns || board.columns;
+
+  console.log(chalk.cyan('\n  📋 Work Board\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(64)));
+
+  for (const col of columns) {
+    const items = board.items.filter(i => i.column === col || (!i.column && col === columns[0]));
+    const colLabel = col === 'todo' ? '📋 To Do' : col === 'in-progress' ? '🔄 In Progress' : col === 'done' ? '✅ Done' : col;
+    console.log(chalk.white(`\n  ${colLabel} (${items.length})`));
+
+    if (items.length === 0) {
+      console.log(chalk.gray('    (empty)'));
+    } else {
+      for (const item of items) {
+        const id = item.id || '';
+        const text = item.text || '';
+        const priority = item.priority || '';
+        const prioTag = priority === 'high' ? chalk.red('‼️') : priority === 'medium' ? chalk.yellow('❗') : priority === 'low' ? chalk.gray('📌') : '';
+        console.log(`  ${chalk.gray(`[${id}]`)} ${prioTag} ${chalk.white(text.substring(0, 60))}${text.length > 60 ? '…' : ''}`);
+      }
+    }
+  }
+
+  console.log(chalk.gray('\n  ' + '─'.repeat(64)));
+  console.log(chalk.gray(`  ${board.items.length} total items across ${columns.length} columns`));
+  console.log(chalk.gray('\n  Commands:'));
+  console.log(chalk.cyan('    add <text>') + chalk.gray('          Add item to To Do'));
+  console.log(chalk.cyan('    move <id> <column>') + chalk.gray('   Move item to column'));
+  console.log(chalk.cyan('    remove <id>') + chalk.gray('         Remove item'));
+  console.log(chalk.cyan('    columns list/set') + chalk.gray('    Manage columns'));
+  console.log(chalk.cyan('    export') + chalk.gray('              Export board as JSON'));
+  console.log(chalk.cyan('    import <file>') + chalk.gray('      Import board from JSON'));
+  console.log(chalk.cyan('    clear') + chalk.gray('               Clear all items'));
+  console.log();
+}
+
+function addItem(text) {
+  if (!text) {
+    console.log(chalk.red('\n  ❌ Text gerekli\n'));
+    console.log(chalk.cyan('    natureco workboard add "Task description"\n'));
+    process.exit(1);
+  }
+
+  const board = loadBoard();
+  const id = Date.now().toString(36) + Math.random().toString(36).slice(2, 5);
+  board.items.push({
+    id,
+    text,
+    column: board.columns[0] || 'todo',
+    priority: 'medium',
+    created: new Date().toISOString()
+  });
+  saveBoard(board);
+  console.log(chalk.green(`\n  ✅ Added: ${chalk.white(text)} ${chalk.gray(`[${id}]`)}\n`));
+}
+
+function moveItem(id, column) {
+  if (!id || !column) {
+    console.log(chalk.red('\n  ❌ id ve column gerekli\n'));
+    console.log(chalk.cyan('    natureco workboard move <id> done\n'));
+    process.exit(1);
+  }
+
+  const board = loadBoard();
+  const item = board.items.find(i => i.id === id);
+  if (!item) {
+    console.log(chalk.red(`\n  ❌ Item bulunamadı: ${id}\n`));
+    process.exit(1);
+  }
+
+  item.column = column;
+  item.updated = new Date().toISOString();
+  saveBoard(board);
+  console.log(chalk.green(`\n  ✅ Moved "${item.text.substring(0, 40)}" → ${column}\n`));
+}
+
+function removeItem(id) {
+  if (!id) {
+    console.log(chalk.red('\n  ❌ id gerekli\n'));
+    process.exit(1);
+  }
+
+  const board = loadBoard();
+  const idx = board.items.findIndex(i => i.id === id);
+  if (idx === -1) {
+    console.log(chalk.red(`\n  ❌ Item bulunamadı: ${id}\n`));
+    process.exit(1);
+  }
+
+  const removed = board.items.splice(idx, 1)[0];
+  saveBoard(board);
+  console.log(chalk.green(`\n  ✅ Removed: ${removed.text.substring(0, 40)}\n`));
+}
+
+function clearBoard() {
+  const board = loadBoard();
+  board.items = [];
+  saveBoard(board);
+  console.log(chalk.gray('\n  🗑️  Board temizlendi\n'));
+}
+
+function manageColumns(params) {
+  const config = getConfig();
+  if (!config.workboard) config.workboard = {};
+
+  if (params[0] === 'set') {
+    const cols = params.slice(1);
+    if (cols.length === 0) {
+      console.log(chalk.red('\n  ❌ En az bir kolon gerekli\n'));
+      process.exit(1);
+    }
+    config.workboard.columns = cols;
+    saveConfig(config);
+    console.log(chalk.green(`\n  ✅ Columns set: ${cols.join(', ')}\n`));
+    return;
+  }
+
+  const board = loadBoard();
+  const columns = config.workboard.columns || board.columns;
+  console.log(chalk.cyan('\n  📋 Columns\n'));
+  for (const col of columns) {
+    const count = board.items.filter(i => i.column === col).length;
+    console.log(`  ${chalk.white(col)} ${chalk.gray(`(${count} items)`)}`);
+  }
+  console.log(chalk.gray('\n  Set columns:'));
+  console.log(chalk.cyan('    natureco workboard columns set todo in-progress review done'));
+  console.log();
+}
+
+function exportBoard() {
+  const board = loadBoard();
+  console.log(chalk.cyan('\n  📋 Board Export\n'));
+  console.log(JSON.stringify(board, null, 2));
+  console.log();
+}
+
+function importBoard(filePath) {
+  if (!filePath) {
+    console.log(chalk.red('\n  ❌ Dosya gerekli\n'));
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(filePath)) {
+    console.log(chalk.red(`\n  ❌ Dosya bulunamadı: ${filePath}\n`));
+    process.exit(1);
+  }
+
+  try {
+    const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    if (!data.items || !Array.isArray(data.items)) {
+      console.log(chalk.red('\n  ❌ Geçersiz board JSON (items array gerekli)\n'));
+      process.exit(1);
+    }
+
+    saveBoard(data);
+    console.log(chalk.green(`\n  ✅ Board imported: ${data.items.length} items\n`));
+  } catch (err) {
+    console.log(chalk.red(`\n  ❌ Import hatası: ${err.message}\n`));
+    process.exit(1);
+  }
+}
+
+module.exports = workboard;

package/src/tools/audio_understanding.js

@@ -0,0 +1,154 @@
+const { getConfig } = require('../utils/config');
+const fs = require('fs');
+const path = require('path');
+
+async function transcribeWithWhisper(audioPath, apiKey) {
+  const formData = new FormData();
+  const file = await fs.promises.readFile(audioPath);
+  const blob = new Blob([file]);
+  formData.append('file', blob, path.basename(audioPath));
+  formData.append('model', 'whisper-1');
+
+  const response = await fetch('https://api.openai.com/v1/audio/transcriptions', {
+    method: 'POST',
+    headers: { 'Authorization': `Bearer ${apiKey}` },
+    body: formData
+  });
+
+  if (!response.ok) throw new Error(`Whisper error ${response.status}: ${await response.text()}`);
+  const data = await response.json();
+  return data.text;
+}
+
+async function transcribeWithDeepgram(audioPath, apiKey) {
+  const file = await fs.promises.readFile(audioPath);
+  const response = await fetch('https://api.deepgram.com/v1/listen', {
+    method: 'POST',
+    headers: {
+      'Authorization': `Token ${apiKey}`,
+      'Content-Type': 'audio/wav'
+    },
+    body: file
+  });
+
+  if (!response.ok) throw new Error(`Deepgram error ${response.status}: ${await response.text()}`);
+  const data = await response.json();
+  return data.results?.channels?.[0]?.alternatives?.[0]?.transcript || '';
+}
+
+async function analyzeAudio(text, provider, apiKey, analysisPrompt) {
+  const baseUrl = provider === 'openai' ? 'https://api.openai.com/v1' : `https://api.${provider}.com/v1`;
+
+  const prompt = analysisPrompt || 'Analyze this audio transcript. Identify speakers, extract key points, detect sentiment, and summarize.';
+
+  const response = await fetch(`${baseUrl}/chat/completions`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
+    body: JSON.stringify({
+      model: provider === 'openai' ? 'gpt-4o' : 'claude-3-haiku-20240307',
+      messages: [
+        { role: 'system', content: prompt },
+        { role: 'user', content: `Transcript:\n\n${text}` }
+      ],
+      max_tokens: 4096
+    })
+  });
+
+  if (!response.ok) throw new Error(`Analysis error ${response.status}: ${await response.text()}`);
+  return (await response.json()).choices?.[0]?.message?.content || '';
+}
+
+module.exports = {
+  name: 'audio_understanding',
+  description: 'Analyze audio files — transcribe speech and extract insights using AI (OpenAI Whisper + LLM, Deepgram)',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      audioPath: { type: 'string', description: 'Path to audio file (mp3, wav, m4a, ogg)' },
+      audioUrl: { type: 'string', description: 'URL to audio file (alternative to audioPath)' },
+      action: { type: 'string', description: 'Action: transcribe, analyze, full', enum: ['transcribe', 'analyze', 'full'], default: 'full' },
+      transcriptionProvider: { type: 'string', description: 'Transcription provider: openai, deepgram (default: openai)', enum: ['openai', 'deepgram'] },
+      analysisProvider: { type: 'string', description: 'Analysis provider: openai, anthropic (default: openai)', enum: ['openai', 'anthropic'] },
+      analysisPrompt: { type: 'string', description: 'Custom analysis prompt' },
+      language: { type: 'string', description: 'Language code (e.g. tr, en, de)' }
+    },
+    required: ['action']
+  },
+
+  async execute(params) {
+    try {
+      const config = getConfig();
+      let audioPath = params.audioPath;
+
+      if (params.audioUrl && !audioPath) {
+        const tmpDir = require('os').tmpdir();
+        const tmpFile = path.join(tmpDir, `audio_${Date.now()}.tmp`);
+        const response = await fetch(params.audioUrl);
+        if (!response.ok) throw new Error(`Failed to download audio: ${response.status}`);
+        const buffer = Buffer.from(await response.arrayBuffer());
+        await fs.promises.writeFile(tmpFile, buffer);
+        audioPath = tmpFile;
+      }
+
+      if (!audioPath) {
+        return { success: false, error: 'audioPath veya audioUrl gerekli' };
+      }
+
+      if (!fs.existsSync(audioPath)) {
+        return { success: false, error: `Dosya bulunamadı: ${audioPath}` };
+      }
+
+      const transcribeProv = params.transcriptionProvider || 'openai';
+      let transcribeKey;
+
+      if (transcribeProv === 'openai') {
+        transcribeKey = config.openaiApiKey || process.env.OPENAI_API_KEY;
+      } else if (transcribeProv === 'deepgram') {
+        transcribeKey = config.deepgramApiKey || process.env.DEEPGRAM_API_KEY;
+      }
+
+      if (!transcribeKey) {
+        return { success: false, error: `${transcribeProv} API key gerekli` };
+      }
+
+      const result = { success: true, action: params.action || 'full' };
+
+      if (params.action === 'transcribe' || params.action === 'full' || !params.action) {
+        const transcript = transcribeProv === 'deepgram'
+          ? await transcribeWithDeepgram(audioPath, transcribeKey)
+          : await transcribeWithWhisper(audioPath, transcribeKey);
+
+        result.transcript = transcript;
+        result.transcriptionProvider = transcribeProv;
+      }
+
+      if (params.action === 'analyze' || params.action === 'full') {
+        const transcriptForAnalysis = result.transcript || (transcribeProv === 'deepgram'
+          ? await transcribeWithDeepgram(audioPath, transcribeKey)
+          : await transcribeWithWhisper(audioPath, transcribeKey));
+
+        const analysisProv = params.analysisProvider || 'openai';
+        const analysisApiKey = analysisProv === 'openai'
+          ? (config.openaiApiKey || process.env.OPENAI_API_KEY)
+          : (config.anthropicApiKey || process.env.ANTHROPIC_API_KEY);
+
+        if (!analysisApiKey) {
+          return { success: false, error: `${analysisProv} API key gerekli` };
+        }
+
+        const analysis = await analyzeAudio(transcriptForAnalysis, analysisProv, analysisApiKey, params.analysisPrompt);
+        result.analysis = analysis;
+        result.analysisProvider = analysisProv;
+        result.transcript = transcriptForAnalysis;
+      }
+
+      if (audioPath !== params.audioPath && audioPath) {
+        await fs.promises.unlink(audioPath).catch(() => {});
+      }
+
+      return result;
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+};

package/src/tools/bash.js

@@ -1,5 +1,7 @@
 const { execSync } = require('child_process');
 const os = require('os');
+const chalk = require('chalk');
+const { isDangerousCommand, checkCommand, isSafeCommand } = require('../utils/approvals');
 
 module.exports = {
   name: 'bash',
@@ -17,43 +19,75 @@ module.exports = {
   
   async execute(params) {
     try {
-      // Security: Block dangerous commands
-      const DANGEROUS_COMMANDS = ['kill', 'rm -rf', 'sudo rm', 'pkill', 'killall', 'shutdown', 'reboot', 'format'];
-      const isDangerous = DANGEROUS_COMMANDS.some(cmd => params.command.includes(cmd));
-      
-      if (isDangerous) {
+      if (!params.command || !params.command.trim()) {
+        return { success: false, error: 'No command provided' };
+      }
+
+      const command = params.command;
+
+      // Skip approval checks for safe commands
+      if (isSafeCommand(command)) {
+        return runCommand(command);
+      }
+
+      // Check command against approvals policy
+      const approval = await checkCommand(command, { agentId: 'default' });
+
+      if (!approval.allowed) {
+        if (approval.reason === 'denied-by-policy') {
+          return {
+            success: false,
+            error: 'Command execution is denied by security policy. Use "natureco security allowlist add" to allow specific commands.',
+          };
+        }
+        if (approval.reason === 'not-in-allowlist') {
+          return {
+            success: false,
+            error: 'Command is not in the allowlist. Use "natureco security allowlist add" to add it, or set a less restrictive policy.',
+          };
+        }
+        return { success: false, error: `Command rejected: ${approval.reason}` };
+      }
+
+      // Check for dangerous commands that weren't already user-approved
+      if (isDangerousCommand(command)) {
+        console.log(chalk.yellow('\n  ⚠️  Potentially dangerous command'));
+        console.log(chalk.gray('  ') + command);
+        console.log('');
         return {
           success: false,
-          error: 'Bu komut güvenlik nedeniyle engellendi. Kullanıcıdan onay alınması gerekiyor.'
+          error: 'Dangerous command blocked. Run manually after review.',
         };
       }
-      
-      // Replace /home with actual home directory (Unix only)
-      // Handles: /home, /home/Documents, /home/anything
-      let command = params.command;
-      if (process.platform !== 'win32') {
-        command = command.replace(/\/home(\/[^\s]*)?/g, (match, subpath) => {
-          return os.homedir() + (subpath || '');
-        });
-      }
-      
-      const output = execSync(command, {
-        encoding: 'utf-8',
-        maxBuffer: 10 * 1024 * 1024, // 10MB
-        timeout: 30000, // 30 seconds
-        shell: true // Use shell for command execution
-      });
-      
-      return {
-        success: true,
-        output: output.trim()
-      };
+
+      return runCommand(approval.editedCommand || command);
     } catch (error) {
       return {
         success: false,
-        error: error.message,
-        stderr: error.stderr?.toString() || ''
+        error: error?.message ?? 'Unknown error',
+        stderr: error?.stderr?.toString() ?? '',
       };
     }
   }
 };
+
+function runCommand(command) {
+  let cmd = command;
+  if (process.platform !== 'win32') {
+    cmd = cmd.replace(/\/home(\/[^\s]*)?/g, (match, subpath) => {
+      return os.homedir() + (subpath || '');
+    });
+  }
+
+  const output = execSync(cmd, {
+    encoding: 'utf-8',
+    maxBuffer: 10 * 1024 * 1024,
+    timeout: 30000,
+    shell: true,
+  });
+
+  return {
+    success: true,
+    output: output.trim(),
+  };
+}

package/src/tools/browser.js

@@ -0,0 +1,112 @@
+const { getConfig } = require('../utils/config');
+
+async function tryPlaywright(action, params) {
+  try {
+    const { chromium } = require('playwright');
+    const browser = await chromium.launch({ headless: true });
+    try {
+      const page = await browser.newPage();
+
+      if (action === 'open') {
+        await page.goto(params.url, { waitUntil: 'networkidle', timeout: 30000 });
+        const title = await page.title();
+        const content = await page.evaluate(() => document.body.innerText);
+        return { success: true, action, title, url: params.url, content: content.substring(0, 10000) };
+      }
+
+      if (action === 'screenshot') {
+        await page.goto(params.url, { waitUntil: 'networkidle', timeout: 30000 });
+        const screenshot = await page.screenshot({ type: 'png', fullPage: params.fullPage !== false });
+        return { success: true, action, url: params.url, screenshot: screenshot.toString('base64'), format: 'png' };
+      }
+
+      if (action === 'evaluate') {
+        await page.goto(params.url, { waitUntil: 'networkidle', timeout: 30000 });
+        const result = await page.evaluate(params.script);
+        return { success: true, action, url: params.url, result: JSON.stringify(result) };
+      }
+
+      if (action === 'html') {
+        await page.goto(params.url, { waitUntil: 'networkidle', timeout: 30000 });
+        const html = await page.content();
+        return { success: true, action, url: params.url, html: html.substring(0, 50000) };
+      }
+
+      return { success: false, error: `Unknown browser action: ${action}` };
+    } finally {
+      await browser.close();
+    }
+  } catch (err) {
+    if (err.code === 'MODULE_NOT_FOUND' || err.message?.includes('Cannot find module')) {
+      return { success: false, error: 'Playwright kurulu değil. Yüklemek için: npm install playwright', fallback: true };
+    }
+    return { success: false, error: err.message };
+  }
+}
+
+async function httpFallback(url) {
+  try {
+    const https = require('https');
+    const http = require('http');
+    const transport = url.startsWith('https') ? https : http;
+
+    return new Promise((resolve) => {
+      const req = transport.get(url, { headers: { 'User-Agent': 'NatureCo-CLI/2.0' }, timeout: 15000 }, (res) => {
+        let data = '';
+        res.on('data', (chunk) => { data += chunk; });
+        res.on('end', () => {
+          const title = data.match(/<title>([^<]*)<\/title>/i)?.[1]?.trim() || '';
+          const text = data.replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
+          resolve({ success: true, action: 'open', title, url, content: text.substring(0, 10000), mode: 'http-fallback' });
+        });
+      });
+      req.on('error', (err) => resolve({ success: false, error: err.message }));
+      req.on('timeout', () => { req.destroy(); resolve({ success: false, error: 'timeout' }); });
+    });
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+
+module.exports = {
+  name: 'browser',
+  description: 'Headless browser automation — open URLs, take screenshots, evaluate JS, get HTML. Uses Playwright if available, falls back to HTTP.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: { type: 'string', description: 'Action: open, screenshot, evaluate, html', enum: ['open', 'screenshot', 'evaluate', 'html'] },
+      url: { type: 'string', description: 'URL to navigate to' },
+      script: { type: 'string', description: 'JavaScript to evaluate (for evaluate action)' },
+      fullPage: { type: 'boolean', description: 'Full page screenshot (default: true)' }
+    },
+    required: ['action', 'url']
+  },
+
+  async execute(params) {
+    if (params.action === 'open') {
+      const pw = await tryPlaywright('open', params);
+      if (pw.fallback) return httpFallback(params.url);
+      return pw;
+    }
+
+    if (params.action === 'screenshot') {
+      const pw = await tryPlaywright('screenshot', params);
+      if (pw.fallback) return { success: false, error: 'Screenshot için Playwright gerekli. Kur: npm install playwright' };
+      return pw;
+    }
+
+    if (params.action === 'evaluate') {
+      const pw = await tryPlaywright('evaluate', params);
+      if (pw.fallback) return { success: false, error: 'JS evaluate için Playwright gerekli. Kur: npm install playwright' };
+      return pw;
+    }
+
+    if (params.action === 'html') {
+      const pw = await tryPlaywright('html', params);
+      if (pw.fallback) return httpFallback(params.url);
+      return pw;
+    }
+
+    return { success: false, error: `Unknown action: ${params.action}` };
+  }
+};

package/src/tools/canvas.js

@@ -0,0 +1,104 @@
+module.exports = {
+  name: 'canvas',
+  description: 'Create and display rich content: tables, charts, formatted text, and structured data',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      type: { type: 'string', description: 'Canvas type: table, markdown, code, data, separator, heading', enum: ['table', 'markdown', 'code', 'data', 'separator', 'heading'] },
+      title: { type: 'string', description: 'Section title' },
+      content: { type: 'string', description: 'Text content for markdown/code types' },
+      headers: { type: 'array', items: { type: 'string' }, description: 'Column headers (for table type)' },
+      rows: { type: 'array', items: { type: 'array', items: { type: 'string' } }, description: 'Table rows (for table type)' },
+      data: { type: 'object', description: 'Structured data to display (for data type)' },
+      language: { type: 'string', description: 'Code language (for code type)' }
+    },
+    required: ['type']
+  },
+
+  async execute(params) {
+    try {
+      const chalk = require('chalk');
+      const w = process.stdout.columns || 80;
+      const line = chalk.gray('─'.repeat(w));
+      const thin = chalk.gray('─'.repeat(40));
+
+      let output = ['', line];
+
+      if (params.title) {
+        output.push(chalk.bold.cyan(`  ${params.title}`));
+        output.push(thin);
+      }
+
+      if (params.type === 'heading') {
+        output = ['', '', chalk.bold.green(`  ${'█'.repeat(4)} ${params.content}`), ''];
+        output.push(line);
+      }
+
+      if (params.type === 'separator') {
+        output = ['', line, ''];
+      }
+
+      if (params.type === 'markdown') {
+        const lines = (params.content || '').split('\n');
+        for (const lineText of lines) {
+          output.push(lineText.startsWith('#')
+            ? chalk.bold.cyan(`  ${lineText}`)
+            : lineText.startsWith('-') || lineText.startsWith('*')
+            ? chalk.white(`  ${lineText}`)
+            : lineText.startsWith('>')
+            ? chalk.gray(`  ${lineText}`)
+            : chalk.white(`  ${lineText}`));
+        }
+      }
+
+      if (params.type === 'code') {
+        const lang = params.language || 'text';
+        output.push(chalk.gray(`  ── ${lang} ──`));
+        const codeLines = (params.content || '').split('\n');
+        for (const lineText of codeLines) {
+          output.push(chalk.yellow(`  │ ${lineText}`));
+        }
+        output.push(chalk.gray('  ' + '─'.repeat(40)));
+      }
+
+      if (params.type === 'table') {
+        const headers = params.headers || [];
+        const rows = params.rows || [];
+
+        if (headers.length > 0) {
+          const headerLine = headers.map(h => chalk.bold.cyan(h.padEnd(20))).join(' │ ');
+          output.push(`  ${headerLine}`);
+          output.push(chalk.gray(`  ${'─'.repeat(Math.max(40, headers.length * 22))}`));
+        }
+
+        for (const row of rows) {
+          const rowLine = row.map((cell, i) => {
+            const width = headers[i] ? headers[i].length : 20;
+            return (cell || '').padEnd(Math.max(width, 20));
+          }).join(' │ ');
+          output.push(`  ${rowLine}`);
+        }
+      }
+
+      if (params.type === 'data') {
+        const d = params.data || {};
+        for (const [key, value] of Object.entries(d)) {
+          const val = typeof value === 'object' ? JSON.stringify(value) : String(value);
+          output.push(chalk.white(`  ${key}`) + chalk.gray(': ') + chalk.cyan(val.length > 60 ? val.slice(0, 60) + '...' : val));
+        }
+      }
+
+      output.push(line);
+      output.push('');
+
+      return {
+        success: true,
+        type: params.type,
+        output: output.join('\n'),
+        rendered: true
+      };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+};