trace.ai-cli 1.1.8 → 1.2.0

package/utils/encryption.js

@@ -1,42 +1,42 @@
-const ENCRYPTION_KEY = 'AlzaSyCVKlzUxK';
-
-function encodeUnicode(str) {
-    const utf8Bytes = new TextEncoder().encode(str);
-    return Buffer.from(utf8Bytes).toString('base64');
-}
-
-function decodeUnicode(str) {
-    const bytes = Buffer.from(str, 'base64');
-    return new TextDecoder().decode(bytes);
-}
-
-function encryptData(data) {
-    const jsonStr = JSON.stringify(data);
-    // Match worker.js approach: encode to base64 then reverse
-    const base64 = Buffer.from(
-        Array.from(new TextEncoder().encode(jsonStr))
-            .map(byte => String.fromCharCode(byte))
-            .join('')
-    ).toString('base64');
-    
-    return base64.split('').reverse().join('');
-}
-
-function decryptData(encoded) {
-    try {
-        // Match worker.js approach: reverse then decode
-        const reversed = encoded.split('').reverse().join('');
-        const binaryStr = Buffer.from(reversed, 'base64').toString('binary');
-        const bytes = Uint8Array.from(binaryStr, char => char.charCodeAt(0));
-        const decoded = new TextDecoder().decode(bytes);
-        return JSON.parse(decoded);
-    } catch (error) {
-        console.error('Decryption failed:', error);
-        throw new Error('Invalid encrypted data');
-    }
-}
-
-module.exports = {
-    encryptData,
-    decryptData
+const ENCRYPTION_KEY = 'AlzaSyCVKlzUxK';
+
+function encodeUnicode(str) {
+    const utf8Bytes = new TextEncoder().encode(str);
+    return Buffer.from(utf8Bytes).toString('base64');
+}
+
+function decodeUnicode(str) {
+    const bytes = Buffer.from(str, 'base64');
+    return new TextDecoder().decode(bytes);
+}
+
+function encryptData(data) {
+    const jsonStr = JSON.stringify(data);
+    // Match worker.js approach: encode to base64 then reverse
+    const base64 = Buffer.from(
+        Array.from(new TextEncoder().encode(jsonStr))
+            .map(byte => String.fromCharCode(byte))
+            .join('')
+    ).toString('base64');
+    
+    return base64.split('').reverse().join('');
+}
+
+function decryptData(encoded) {
+    try {
+        // Match worker.js approach: reverse then decode
+        const reversed = encoded.split('').reverse().join('');
+        const binaryStr = Buffer.from(reversed, 'base64').toString('binary');
+        const bytes = Uint8Array.from(binaryStr, char => char.charCodeAt(0));
+        const decoded = new TextDecoder().decode(bytes);
+        return JSON.parse(decoded);
+    } catch (error) {
+        console.error('Decryption failed:', error);
+        throw new Error('Invalid encrypted data');
+    }
+}
+
+module.exports = {
+    encryptData,
+    decryptData
 };

package/utils/fileUtils.js

@@ -42,18 +42,22 @@ function getFileType(filePath) {
         '.bash': 'Bash Script',
         '.zsh': 'Zsh Script',
         '.ps1': 'PowerShell',
-        '.bat': 'Batch Script',
         '.dockerfile': 'Dockerfile',
         '.gitignore': 'Git Ignore',
         '.env': 'Environment Variables'
     };
     
     const imageExtensions = ['.jpg', '.jpeg', '.png', '.gif', '.webp', '.bmp', '.svg'];
+    const documentExtensions = ['.pdf', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx'];
     
     if (imageExtensions.includes(ext)) {
         return 'image';
     }
     
+    if (documentExtensions.includes(ext)) {
+        return 'document';
+    }
+    
     return codeExtensions[ext] || 'Unknown';
 }
 
@@ -66,7 +70,8 @@ function getMimeType(filePath) {
         '.gif': 'image/gif',
         '.webp': 'image/webp',
         '.bmp': 'image/bmp',
-        '.svg': 'image/svg+xml'
+        '.svg': 'image/svg+xml',
+        '.pdf': 'application/pdf'
     };
     return mimeTypes[ext] || 'image/jpeg';
 }

package/utils/markdown.js

@@ -0,0 +1,168 @@
+// markdown.js
+// Minimal Markdown renderer (safe): supports **bold**, `code`, bullet lists, and fenced code blocks ```lang
+// Additionally provides a terminal-friendly ANSI renderer for Node CLI.
+
+function escapeHtml(s) {
+  return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+
+// Terminal-friendly Markdown to ANSI using chalk (Node only)
+function markdownToAnsi(md) {
+  if (!md) return '';
+  const chalk = (typeof window === 'undefined') ? require('chalk') : null;
+  const lines = md.replace(/\r\n?/g, '\n').split('\n');
+  let out = '';
+  let inCode = false;
+  let codeLines = [];
+
+  const flushCode = () => {
+    if (!inCode) return;
+    const codeText = codeLines.join('\n');
+    out += '\n' + chalk.gray('┌─ code ───────────────────────────────') + '\n';
+    out += chalk.white(codeText) + '\n';
+    out += chalk.gray('└──────────────────────────────────────') + '\n';
+    inCode = false;
+    codeLines = [];
+  };
+
+  for (let raw of lines) {
+    const line = raw.trimEnd();
+    const fenceMatch = /^```/.test(line);
+    if (fenceMatch) {
+      if (!inCode) {
+        inCode = true; codeLines = []; continue;
+      } else {
+        flushCode(); continue;
+      }
+    }
+    if (inCode) { codeLines.push(raw); continue; }
+
+    const bullet = /^\s*([*-])\s+(.+)$/.exec(line);
+    if (bullet) {
+      const item = bullet[2]
+        .replace(/\*\*(.+?)\*\*/g, (_, t) => chalk.bold(t))
+        .replace(/`([^`]+)`/g, (_, t) => chalk.black.bgYellow(` ${t} `));
+      out += chalk.blue('• ') + item + '\n';
+      continue;
+    }
+
+    if (line.trim() === '') { out += '\n'; continue; }
+
+    const para = line
+      .replace(/\*\*(.+?)\*\*/g, (_, t) => chalk.bold(t))
+      .replace(/`([^`]+)`/g, (_, t) => chalk.black.bgYellow(` ${t} `));
+    out += para + '\n';
+  }
+  flushCode();
+  return out;
+}
+
+function markdownToHtml(md) {
+  if (!md) return '';
+  // Normalize line endings
+  md = md.replace(/\r\n?/g, '\n');
+  const lines = md.split('\n');
+  let html = '';
+  let inList = false;
+  let inCode = false;
+  let codeLang = '';
+  let codeLines = [];
+
+  const flushList = () => { if (inList) { html += '</ul>'; inList = false; } };
+
+  for (let raw of lines) {
+    let line = raw.trimEnd();
+
+    // Fenced code blocks
+    const fenceMatch = /^```\s*([A-Za-z0-9_+-]*)\s*$/.exec(line);
+    if (fenceMatch) {
+      if (!inCode) {
+        // starting code block
+        flushList();
+        inCode = true;
+        codeLang = fenceMatch[1] || '';
+        codeLines = [];
+      } else {
+        // ending code block -> flush code block
+        const codeText = codeLines.join('\n');
+        const codeEsc = escapeHtml(codeText);
+        const langClass = codeLang ? `language-${codeLang}` : '';
+        html += `<div class="code-block">\n<button class="copy-btn" title="Copy code" aria-label="Copy code">Copy</button><pre><code class="${langClass}">${codeEsc}</code></pre></div>`;
+        inCode = false;
+        codeLang = '';
+        codeLines = [];
+      }
+      continue;
+    }
+
+    if (inCode) {
+      codeLines.push(raw); // preserve exact indentation inside code
+      continue;
+    }
+
+    const bulletMatch = /^\s*([*-])\s+(.+)$/.exec(line);
+    if (bulletMatch) {
+      if (!inList) { html += '<ul>'; inList = true; }
+      const item = bulletMatch[2];
+      const itemEsc = escapeHtml(item)
+        .replace(/\*\*(.+?)\*\*/g, '<strong>$1</strong>')
+        .replace(/`([^`]+)`/g, '<code>$1</code>');
+      html += `<li>${itemEsc}</li>`;
+      continue;
+    }
+
+    // Empty line -> paragraph break
+    if (line.trim() === '') {
+      flushList(); html += '<br/>';
+      continue;
+    }
+
+    // Normal paragraph line
+    flushList();
+    const para = escapeHtml(line)
+      .replace(/\*\*(.+?)\*\*/g, '<strong>$1</strong>')
+      .replace(/`([^`]+)`/g, '<code>$1</code>');
+    html += `<p>${para}</p>`;
+  }
+
+  flushList();
+
+  // If code block was never closed, flush it anyway
+  if (inCode) {
+    const codeText = codeLines.join('\n');
+    const codeEsc = escapeHtml(codeText);
+    const langClass = codeLang ? `language-${codeLang}` : '';
+    html += `<div class="code-block"><button class="copy-btn" title="Copy code" aria-label="Copy code">📋</button><pre><code class="${langClass}">${codeEsc}</code></pre></div>`;
+  }
+
+  return html;
+}
+
+// Optional: centralize copy button handler so renderer.js stays clean
+function initMarkdownCopyHandler() {
+  document.addEventListener('click', async (e) => {
+    const btn = e.target.closest('.copy-btn');
+    if (!btn) return;
+    try {
+      const wrapper = btn.closest('.code-block');
+      const codeEl = wrapper ? wrapper.querySelector('code') : null;
+      const codeText = codeEl ? codeEl.textContent : '';
+      if (!codeText) return;
+      await navigator.clipboard.writeText(codeText);
+      const prev = btn.textContent;
+      btn.textContent = 'Copied!';
+      setTimeout(() => { btn.textContent = prev; }, 1200);
+    } catch (_) { }
+  });
+}
+
+  // Expose to browser global when available
+  if (typeof window !== 'undefined') {
+    window.markdownToHtml = markdownToHtml;
+    window.initMarkdownCopyHandler = initMarkdownCopyHandler;
+  }
+
+// Support CommonJS environments if available (harmless in extension builds)
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = { markdownToHtml, initMarkdownCopyHandler, markdownToAnsi };
+}