Something went wrong. Try again.
Monorepo for Aesthetic.Computer aesthetic.computer
Something went wrong. Try again.
JavaScript
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089#!/usr/bin/env node// KidLisp Source Tree Analyzer// Usage: ./source-tree.mjs $cow// Output: A visual tree representation of KidLisp piece dependencies
import { execSync } from 'child_process';import chalk from 'chalk';import terminalKit from 'terminal-kit';import gradient from 'gradient-string';
const term = terminalKit.terminal;// Shows the embedd// Format piece name with bright gradient effects and $ prefixfunction formatPieceName(pieceName, showDollar = true) { let result = ''; // Always add bright gradient $ prefix for piece names if (showDollar) { result += gradient('lime', 'cyan')('$'); } // Create brighter gradient colors for better visibility const brightGradientColors = ['#ff1493', '#00ffff', '#ffff00', '#ff4500', '#adff2f', '#ff69b4']; const startColor = brightGradientColors[pieceName.length % brightGradientColors.length]; const endColor = brightGradientColors[(pieceName.length + 2) % brightGradientColors.length]; // Apply bright gradient to the piece name const gradientText = gradient(startColor, endColor)(pieceName); return result + gradientText;}
import https from 'https';
// Import KidLisp modules for native syntax highlightinglet kidlisp, graph, num;try { kidlisp = await import('../../system/public/aesthetic.computer/lib/kidlisp.mjs'); graph = await import('../../system/public/aesthetic.computer/lib/graph.mjs'); num = await import('../../system/public/aesthetic.computer/lib/num.mjs');} catch (error) { console.warn("⚠️ Warning: Could not load KidLisp modules, using fallback highlighting"); console.warn("Error:", error.message);}
// ANSI terminal colors - using custom RGB instead of default terminal colors// Color utilities using chalk for simpler APIconst colors = { // Basic colors using chalk for text output red: chalk.rgb(220, 50, 47), green: chalk.rgb(50, 200, 50), yellow: chalk.rgb(255, 193, 7), blue: chalk.rgb(38, 139, 210), magenta: chalk.rgb(211, 54, 130), cyan: chalk.rgb(42, 161, 152), white: chalk.rgb(253, 246, 227), gray: chalk.rgb(147, 161, 161), dim: chalk.dim, // ANSI codes for complex formatting (still needed for syntax highlighting) redCode: '\x1b[38;2;220;50;47m', greenCode: '\x1b[38;2;50;200;50m', yellowCode: '\x1b[38;2;255;193;7m', blueCode: '\x1b[38;2;38;139;210m', magentaCode: '\x1b[38;2;211;54;130m', cyanCode: '\x1b[38;2;42;161;152m', whiteCode: '\x1b[38;2;253;246;227m', grayCode: '\x1b[38;2;147;161;161m', reset: '\x1b[0m',};
// Convert KidLisp's \color\text format to ANSI colored text// Convert KidLisp colors to ANSI escape codes with piece recognitionfunction convertKidlispColorsToAnsi(coloredString) { if (!coloredString) return ''; return coloredString .replace(/\$(\w+)/g, (match, pieceName) => { // Apply character-by-character formatting to piece references return formatPieceName(pieceName, true); }) // Handle KidLisp backslash RGB format: \r,g,b\ .replace(/\\(\d+),(\d+),(\d+)\\/g, (match, r, g, b) => { return `\x1b[38;2;${r};${g};${b}m`; }) // Handle KidLisp backslash RGBA format: \r,g,b,a\ (ignore alpha for terminal) .replace(/\\(\d+),(\d+),(\d+),(\d+)\\/g, (match, r, g, b, a) => { return `\x1b[38;2;${r};${g};${b}m`; }) // Handle KidLisp named colors with backslashes: \colorname\ .replace(/\\([a-zA-Z]+)\\/g, (match, colorName) => { return simpleColorToAnsi(colorName) || ''; }) // Handle curly brace RGB format: {r:123,g:456,b:789} .replace(/\{r:(\d+),g:(\d+),b:(\d+)\}/g, (match, r, g, b) => { return `\x1b[38;2;${r};${g};${b}m`; }) .replace(/\{\/\}/g, '\x1b[0m') .replace(/\{\}/g, '\x1b[0m');}
// Convert RGB values to ANSI color (24-bit true color if supported, fallback to 256-color)function rgbToAnsi(r, g, b) { // Calculate brightness to determine if we need special handling const brightness = (r * 0.299 + g * 0.587 + b * 0.114); // Use 24-bit true color if supported (most modern terminals) if (process.env.COLORTERM === 'truecolor' || process.env.COLORTERM === '24bit') { // For very light colors (white, very light gray), use background color for visibility if (brightness > 240) { return `\x1b[48;2;${r};${g};${b}m\x1b[38;2;0;0;0m`; // light background, dark text } // For very dark colors (black, very dark colors), use brighter version or background else if (brightness < 30) { return `\x1b[48;2;${r};${g};${b}m\x1b[38;2;255;255;255m`; // dark background, light text } // Normal foreground color for everything else else { return `\x1b[38;2;${r};${g};${b}m`; } } // Fallback to 256-color approximation if (r === g && g === b) { // Grayscale if (r === 0) return '\x1b[38;5;16m'; // Black if (r === 255) return '\x1b[38;5;231m'; // White const gray = Math.round(r / 255 * 23) + 232; return '\x1b[38;5;' + gray + 'm'; } // Color cube (216 colors) const rIndex = Math.round(r / 255 * 5); const gIndex = Math.round(g / 255 * 5); const bIndex = Math.round(b / 255 * 5); const colorIndex = 16 + (36 * rIndex) + (6 * gIndex) + bIndex; return '\x1b[38;5;' + colorIndex + 'm';}
// Simple color name to ANSI fallbackfunction simpleColorToAnsi(colorName) { switch (colorName.toLowerCase()) { case "red": return '\x1b[38;2;220;50;47m'; case "green": return '\x1b[38;2;50;200;50m'; case "yellow": return '\x1b[38;2;255;193;7m'; case "blue": return '\x1b[38;2;38;139;210m'; case "magenta": return '\x1b[38;2;211;54;130m'; case "cyan": return '\x1b[38;2;42;161;152m'; case "white": return '\x1b[38;2;253;246;227m'; case "gray": case "grey": return '\x1b[38;2;147;161;161m'; case "orange": return '\x1b[38;2;255;165;0m'; // Orange case "purple": return '\x1b[38;2;211;54;130m'; case "lime": return '\x1b[38;2;50;205;50m'; // Lime green case "limegreen": return '\x1b[38;2;50;205;50m'; case "pink": return '\x1b[38;2;255;192;203m'; // Pink case "salmon": return '\x1b[38;2;250;128;114m'; // Salmon case "mediumseagreen": return '\x1b[38;2;60;179;113m'; case "palegreen": return '\x1b[38;2;152;251;152m'; default: return ''; }}
// Track which server is working to use it for all subsequent callslet workingServer = null;let workingUrl = null;
function printUsage() { console.log("Usage: source-tree.mjs <piece-name>"); console.log(" source-tree.mjs @<handle> [limit]"); console.log(" source-tree.mjs --test-colors"); console.log(" source-tree.mjs --debug-colors"); console.log(" source-tree.mjs --test-css-colors"); console.log(""); console.log("Examples:"); console.log(" source-tree.mjs $cow # Show source tree for $cow piece"); console.log(" source-tree.mjs cow # Show source tree ($ prefix optional)"); console.log(" source-tree.mjs @fifi # List all codes by user @fifi"); console.log(" source-tree.mjs @fifi 200 # List up to 200 codes by @fifi"); console.log(""); console.log("Options:"); console.log(" --test-colors Test terminal color capabilities"); console.log(" --debug-colors Debug color name conversions"); console.log(" --test-css-colors Test CSS color name mappings"); console.log(""); console.log("Shows complete source code tree for each piece by default."); console.log("For user handles, displays all codes with syntax highlighting and timestamps.");}
// Function to syntax highlight KidLisp code using native KidLisp highlightingfunction syntaxHighlight(code) { if (!code) return ''; try { // If we have KidLisp and graph modules loaded, use native syntax highlighting if (kidlisp && graph && kidlisp.KidLisp) { // Create a KidLisp instance and use buildColoredKidlispString const kidlispInstance = new kidlisp.KidLisp(); kidlispInstance.initializeSyntaxHighlighting(code); const coloredText = kidlispInstance.buildColoredKidlispString(); // Convert KidLisp's \color\text format to ANSI codes return convertKidlispColorsToAnsi(coloredText); } else { // Use simple fallback highlighting return simpleHighlight(code); } } catch (error) { console.warn('⚠️ KidLisp native highlighting failed:', error.message); return simpleHighlight(code); }}
// Simple fallback highlighting function using chalk for clean color APIfunction simpleHighlight(code) { return code // Piece name references (like $39i, $cow, etc.) .replace(/\$([a-zA-Z0-9_-]+)/g, (match, pieceName) => { return formatPieceName(pieceName, true); }) // Comments .replace(/;[^\n]*/g, match => colors.gray(match)) // String literals .replace(/"[^"]*"/g, match => colors.green(match)) // Numbers .replace(/\b\d+(\.\d+)?\b/g, match => colors.cyan(match)) // Keywords and special forms .replace(/\b(define|if|cond|let|lambda|quote|quasiquote|unquote|and|or|not|car|cdr|cons|list|map|filter|fold|apply)\b/g, match => colors.magenta(match)) // Function calls (first item in parentheses) .replace(/\(([a-zA-Z][a-zA-Z0-9-]*)/g, match => { const parts = match.split('('); const funcName = parts[1]; return `(${colors.yellow(funcName)}`; }) // Embed calls .replace(/#embed\s+([a-zA-Z0-9-]+)/g, match => { const parts = match.split(' '); return `${colors.red('#embed')} ${colors.blue(parts[1])}`; });}
async function fetchSourceFromEndpoint(url, cleanName, isProduction = false) { return new Promise((resolve, reject) => { const timeout = setTimeout(() => { reject(new Error(`Request timeout for ${cleanName}`)); }, 3000); const options = isProduction ? {} : { rejectUnauthorized: false }; https.get(url, options, (res) => { clearTimeout(timeout); let data = ''; res.on('data', (chunk) => { data += chunk; }); res.on('end', () => { try { const response = JSON.parse(data); if (response.error) { reject(new Error(`Piece '$${cleanName}' not found`)); return; } if (!response.source) { reject(new Error("Could not parse source code from response")); return; } // Return the full response object including metadata resolve(response); } catch (error) { reject(new Error("Could not parse JSON response")); } }); }).on('error', (error) => { clearTimeout(timeout); reject(new Error(`Connection failed: ${error.message}`)); }); });}
// Fetch all codes by user handleasync function fetchCodesByHandle(handle, limit = 1000) { const cleanHandle = handle.startsWith('@') ? handle.substring(1) : handle; // Try localhost first (no SSL issues in dev) const localUrl = `https://localhost:8888/.netlify/functions/store-kidlisp?recent=true&limit=${limit}`; try { return await fetchCodesFromEndpoint(localUrl, cleanHandle, limit, false); } catch (localError) { console.log(colors.dim(` Note: localhost unavailable, trying production...`)); // Fallback to production const prodUrl = `https://aesthetic.computer/api/store-kidlisp?recent=true&limit=${limit}`; try { return await fetchCodesFromEndpoint(prodUrl, cleanHandle, limit, true); } catch (prodError) { throw new Error(`Both servers failed: Local: ${localError.message}, Production: ${prodError.message}`); } }}
// Helper to fetch codes from an endpointasync function fetchCodesFromEndpoint(url, cleanHandle, limit, isProduction) { return new Promise((resolve, reject) => { const timeout = setTimeout(() => { reject(new Error('Request timeout')); }, 10000); const options = isProduction ? {} : { rejectUnauthorized: false }; https.get(url, options, (res) => { let data = ''; res.on('data', (chunk) => { data += chunk; }); res.on('end', () => { clearTimeout(timeout); try { const response = JSON.parse(data); if (response.error) { reject(new Error(`Failed to fetch codes: ${response.error}`)); return; } if (!response.recent) { reject(new Error("Invalid response format")); return; } // Filter by handle const userCodes = response.recent.filter(item => item.handle === `@${cleanHandle}` ); resolve(userCodes); } catch (error) { reject(new Error("Could not parse JSON response")); } }); }).on('error', (error) => { clearTimeout(timeout); reject(new Error(`Connection failed: ${error.message}`)); }); });}
// Fetch handle from user IDasync function fetchHandleFromUserId(userId) { if (!userId) return null; // URL encode the userId properly - the pipe | in auth0|xxx needs to be encoded const encodedUserId = encodeURIComponent(userId); const url = `https://aesthetic.computer/.netlify/functions/handle?for=${encodedUserId}`; return new Promise((resolve, reject) => { const timeout = setTimeout(() => { resolve(null); // Don't fail, just return null }, 3000); https.get(url, (res) => { let data = ''; res.on('data', (chunk) => { data += chunk; }); res.on('end', () => { clearTimeout(timeout); try { const response = JSON.parse(data); if (response.handle) { resolve(`@${response.handle}`); } else { resolve(null); } } catch (error) { console.warn(`Failed to fetch handle for ${userId}:`, error.message); resolve(null); } }); }).on('error', (error) => { clearTimeout(timeout); resolve(null); }); });}
async function fetchSource(pieceName) { const cleanName = pieceName.replace(/^\$/, ''); // If we already know which server works, use it directly if (workingServer && workingUrl) { const url = workingUrl.replace(/code=[^&]*/, `code=${cleanName}`); try { const response = await fetchSourceFromEndpoint(url, cleanName, workingServer); // Fetch handle if user ID is present if (response.user) { response.handle = await fetchHandleFromUserId(response.user); } return response; } catch (error) { // Reset and try both servers again workingServer = null; workingUrl = null; } } // Try local development server first const localUrl = `https://localhost:8888/.netlify/functions/store-kidlisp?code=${cleanName}`; try { const response = await fetchSourceFromEndpoint(localUrl, cleanName, 'local'); workingServer = 'local'; workingUrl = localUrl; // Fetch handle if user ID is present if (response.user) { response.handle = await fetchHandleFromUserId(response.user); } return response; } catch (localError) { // Fallback to production const productionUrl = `https://aesthetic.computer/api/store-kidlisp?code=${cleanName}`; try { const response = await fetchSourceFromEndpoint(productionUrl, cleanName, 'production'); workingServer = 'production'; workingUrl = productionUrl; // Fetch handle if user ID is present if (response.user) { response.handle = await fetchHandleFromUserId(response.user); } return response; } catch (prodError) { throw new Error(`Both servers failed: Local: ${localError.message}, Production: ${prodError.message}`); } }}
function extractEmbeddedPieces(source) { // Find all $piece references like ($39i ...) or ($r2f ...) const regex = /\(\$[a-zA-Z0-9_-]+/g; const matches = source.match(regex) || []; // Extract piece names and remove duplicates const pieces = [...new Set(matches.map(match => match.replace('($', '')))]; return pieces;}
// ASCII art generation using toilet command (matching project aesthetic)
// Generate ASCII art for piece names using toilet with beautiful gradientsfunction generateAsciiArt(text, isSubtree = false) { try { // Escape the text properly for shell const safeText = text.replace(/\$/g, '\\$'); // Use different fonts for main vs subtree items const font = isSubtree ? 'smbraille' : 'smblock'; // Generate ASCII art using toilet with appropriate font const result = execSync(`echo "${safeText}" | toilet -f ${font}`, { encoding: 'utf8' }); const lines = result.split('\n').filter(line => line.trim() !== ''); // Apply gradient effects to the ASCII art if (lines.length > 0) { return lines.map(line => { if (isSubtree) { // Green coloring for subtree items (piece references) return gradient(['lime', 'green'])(line); } else { // Dynamic gradient based on the text content for main titles const gradients = [ gradient(['cyan', 'magenta']), gradient(['#ff6b6b', '#4ecdc4']), gradient(['gold', 'orange']), gradient(['lime', 'cyan']), gradient(['purple', 'pink']) ]; const gradientIndex = text.length % gradients.length; return gradients[gradientIndex](line); } }); } // Fallback if (isSubtree) { return [gradient('lime', 'green')(text.toUpperCase())]; } else { return [gradient('cyan', 'magenta')(text.toUpperCase())]; } } catch (error) { // Fallback to gradient colored text if toilet fails if (isSubtree) { return [gradient('lime', 'green')(text.toUpperCase())]; } else { return [gradient('cyan', 'magenta')(text.toUpperCase())]; } }}
// Add a beautiful border around the entire outputfunction addBorder() { const terminalWidth = process.stdout.columns || 80; const borderChar = '█'; const border = borderChar.repeat(terminalWidth); console.log(addFullWidthBackground(border, '40;40;40'));}
// Add full-width background to any line with optional side bordersfunction addFullWidthBackground(content, bgColor = '20;20;20', withBorders = false) { const terminalWidth = process.stdout.columns || 80; // More comprehensive ANSI code removal (including 24-bit RGB codes) const cleanContent = content.replace(/\x1b\[[0-9;]*m/g, '').replace(/\x1b\[48;2;[0-9;]*m/g, '').replace(/\x1b\[38;2;[0-9;]*m/g, ''); if (withBorders) { // Calculate available content width (minus 4 for double borders on each side) const availableWidth = terminalWidth - 4; const padding = Math.max(0, availableWidth - cleanContent.length); const spaces = ' '.repeat(padding); const borderChar = '██'; // Double block for thicker border return `\x1b[48;2;40;40;40m${borderChar}\x1b[0m\x1b[48;2;${bgColor}m${content}${spaces}\x1b[0m\x1b[48;2;40;40;40m${borderChar}\x1b[0m`; } else { // Original behavior for content lines const padding = Math.max(0, terminalWidth - cleanContent.length); const spaces = ' '.repeat(padding); return `\x1b[48;2;${bgColor}m${content}${spaces}\x1b[0m`; }}
// Wrap long lines to fit within the bordered displayfunction wrapLine(text, maxWidth) { const terminalWidth = process.stdout.columns || 80; const availableWidth = maxWidth || (terminalWidth - 8); // Account for borders and spacing // Remove ANSI codes to measure actual text length const stripAnsi = (str) => str.replace(/\x1b\[[0-9;]*m/g, '').replace(/\x1b\[48;2;[0-9;]*m/g, '').replace(/\x1b\[38;2;[0-9;]*m/g, ''); if (stripAnsi(text).length <= availableWidth) { return [text]; } const words = text.split(' '); const lines = []; let currentLine = ''; for (const word of words) { const testLine = currentLine ? `${currentLine} ${word}` : word; if (stripAnsi(testLine).length <= availableWidth) { currentLine = testLine; } else { if (currentLine) { lines.push(currentLine); currentLine = word; } else { // Word is too long, force break lines.push(word); } } } if (currentLine) { lines.push(currentLine); } return lines;}
// Generate unique color for each character based on its valuefunction getCharacterColor(char, index, pieceName) { // Create hash from character and its position const charCode = char.charCodeAt(0); const positionHash = (index + 1) * 37; // Prime number for better distribution const nameHash = pieceName.length * 23; const combinedHash = (charCode + positionHash + nameHash) * 17; // Generate RGB values const r = 120 + (combinedHash * 7) % 135; // 120-255 range for good visibility const g = 120 + (combinedHash * 11) % 135; const b = 120 + (combinedHash * 13) % 135; // Generate background RGB (darker) const bgR = 20 + (combinedHash * 3) % 40; // 20-60 range for dark background const bgG = 20 + (combinedHash * 5) % 40; const bgB = 20 + (combinedHash * 7) % 40; return { fg: `\x1b[38;2;${r};${g};${b}m`, bg: `\x1b[48;2;${bgR};${bgG};${bgB}m`, reset: '\x1b[0m' };}
// Get color for tree depth (creates a nice gradient effect)function getDepthColor(depth) { const depthColors = [ colors.cyanCode, // Level 0: cyan colors.blueCode, // Level 1: blue colors.magentaCode, // Level 2: magenta colors.yellowCode, // Level 3: yellow colors.greenCode, // Level 4: green colors.redCode // Level 5+: red ]; return depthColors[Math.min(depth, depthColors.length - 1)];}
async function printTreeNode(pieceName, depth = 0, prefix = "", showSource = false) { const indent = " ".repeat(depth); // 2-character indentation try { const response = await fetchSource(pieceName); const source = response.source; const cleanSource = source.replace(/\\n/g, '\n').replace(/\\"/g, '"'); const embeddedPieces = extractEmbeddedPieces(source); // Display metadata (handle, timestamp, hits) at the top for root level pieces if (depth === 0 && (response.handle || response.when || response.hits)) { const metadataLine = []; if (response.handle) { metadataLine.push(colors.cyan(`Author: ${response.handle}`)); } if (response.when) { const timestamp = new Date(response.when); const localTime = timestamp.toLocaleString('en-US', { year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', second: '2-digit', hour12: false }); metadataLine.push(colors.dim(`Created: ${localTime}`)); } if (response.hits) { metadataLine.push(colors.gray(`Hits: ${response.hits}`)); } if (metadataLine.length > 0) { console.log(addFullWidthBackground(` ${metadataLine.join(' • ')}`, '20;20;20', true)); console.log(addFullWidthBackground('', '20;20;20', true)); } } // Print current piece with ASCII art for subtree $codes (depth > 0) if (depth > 0) { // Add extra spacing before subtree items console.log(addFullWidthBackground('', '20;20;20', true)); // Generate ASCII art for subtree piece names using smbraille font with green coloring const asciiLines = generateAsciiArt('$' + pieceName, true); asciiLines.forEach(line => { console.log(addFullWidthBackground(` ${line}`, '20;20;20', true)); // 4-space indent with borders }); } if (showSource) { // Print full source code with dark backdrop and barbershop-style striped line numbers const sourceLines = cleanSource.split('\n'); sourceLines.forEach((line, index) => { if (line.trim()) { const lineNumber = (index + 1).toString().padStart(3, ' '); // 3-digit line numbers for consistent alignment const highlightedLine = syntaxHighlight(line); // Wrap long lines to fit within borders const wrappedLines = wrapLine(highlightedLine); wrappedLines.forEach((wrappedLine, wrapIndex) => { // Barbershop alternating backgrounds only on line numbers const lineNumBgColor = (index + 1) % 2 === 0 ? '35;35;35' : '10;10;10'; // Striped line numbers if (wrapIndex === 0) { // First line gets the line number const lineNumFormatted = `\x1b[48;2;${lineNumBgColor}m${lineNumber}\x1b[0m\x1b[48;2;20;20;20m`; // Line number with stripe, then immediately switch to dark backdrop console.log(addFullWidthBackground(`${lineNumFormatted} ${wrappedLine}`, '20;20;20', true)); } else { // Continuation lines get indented without line numbers const continuationSpaces = `\x1b[48;2;20;20;20m `; // 3 spaces to align with line numbers console.log(addFullWidthBackground(`${continuationSpaces} ${wrappedLine}`, '20;20;20', true)); } }); } }); // Remove extra spacing before children - only add if we're at root level AND have embedded pieces if (embeddedPieces.length > 0 && depth === 0) { console.log(addFullWidthBackground('', '20;20;20', true)); // Space only after root level } } else { // Show just first line as preview with striped line number and dark backdrop const firstLine = cleanSource.split('\n')[0]; if (firstLine && firstLine.trim()) { const highlightedLine = syntaxHighlight(firstLine); // Wrap the preview line too const wrappedLines = wrapLine(highlightedLine); wrappedLines.forEach((wrappedLine, wrapIndex) => { if (wrapIndex === 0) { // First line gets line number const lineNumFormatted = `\x1b[48;2;10;10;10m 1\x1b[0m\x1b[48;2;20;20;20m`; // First line gets dark stripe, then dark backdrop console.log(addFullWidthBackground(`${lineNumFormatted} ${wrappedLine}`, '20;20;20', true)); } else { // Continuation lines const continuationSpaces = `\x1b[48;2;20;20;20m `; console.log(addFullWidthBackground(`${continuationSpaces} ${wrappedLine}`, '20;20;20', true)); } }); } } // Process embedded pieces recursively (no pipe graphics, just indentation) if (depth < 5) { for (let i = 0; i < embeddedPieces.length; i++) { const embeddedPiece = embeddedPieces[i]; await printTreeNode(embeddedPiece, depth + 1, "", showSource); } } else if (embeddedPieces.length > 0) { console.log(addFullWidthBackground(`${indent} ... (max depth reached)`, '20;20;20', true)); } } catch (error) { const formattedName = formatPieceName(pieceName); console.log(`${indent}${prefix}${formattedName} ${colors.gray(`(${error.message})`)}`); }}
function analyzePerformanceFeatures(source) { process.stdout.write(`\n${colors.gray('Performance: ')}`); // Check for expensive operations const expensiveOps = []; if (source.includes('blur')) expensiveOps.push('blur'); if (source.includes('zoom')) expensiveOps.push('zoom'); if (source.includes('contrast')) expensiveOps.push('contrast'); if (source.includes('spin')) expensiveOps.push('spin'); if (source.includes('flood')) expensiveOps.push('flood'); if (expensiveOps.length > 0) { console.log(`${expensiveOps.join(', ')}`); } else { console.log('optimized'); } // Check for timing expressions and randomness on same line const features = []; if (source.includes('s(')) features.push('animated'); if (source.includes('?')) features.push('random'); // Count embedded layers const embeddedCount = extractEmbeddedPieces(source).length; if (embeddedCount > 0) features.push(`${embeddedCount} layers`); if (features.length > 0) { console.log(`${colors.gray('Features: ')}${features.join(', ')}`); }}
function testCSSColorsMapping() { console.log('\n🎨 CSS Colors → Terminal Mapping Test:'); // Test common CSS color names that should be recognizable const cssColors = [ 'white', 'black', 'gray', 'grey', 'red', 'green', 'blue', 'yellow', 'cyan', 'magenta', 'orange', 'purple', 'pink', 'brown', 'lime', 'navy', 'teal', 'violet', 'indigo', 'salmon', 'tan', 'gold', 'silver', 'palegreen', 'lightblue', 'darkred', 'lightgray' ]; console.log('\nColor Name → RGB → Terminal Result:'); console.log('═══════════════════════════════════════'); for (const colorName of cssColors) { // Get RGB from graph.findColor let rgba = null; if (graph && graph.findColor) { try { rgba = graph.findColor(colorName); } catch (e) { rgba = null; } } if (rgba && rgba.length >= 3) { const [r, g, b] = rgba; const ansiColor = rgbToAnsi(r, g, b); // Create test text with both foreground and background const fgText = `${ansiColor}${colorName}${COLORS.reset}`; const bgText = `\x1b[48;2;${r};${g};${b}m ${colorName} \x1b[0m`; console.log(`${colorName.padEnd(12)} → RGB(${r.toString().padStart(3)},${g.toString().padStart(3)},${b.toString().padStart(3)}) → FG: ${fgText} BG: ${bgText}`); } else { console.log(`${colorName.padEnd(12)} → NOT FOUND`); } } console.log('\n💡 Color visibility recommendations:'); console.log('• Light colors (white, yellow, cyan) work better with dark backgrounds'); console.log('• Dark colors (black, navy, darkred) work better with light backgrounds'); console.log('• Consider using background colors for very light/dark text');}
// Display all codes by a user handle with syntax highlightingasync function displayUserCodes(handle, limit = 1000) { const cleanHandle = handle.startsWith('@') ? handle.substring(1) : handle; // Create beautiful ASCII art title const asciiLines = generateAsciiArt(`@${cleanHandle}`); // Add top border addBorder(); console.log(addFullWidthBackground('', '20;20;20', true)); asciiLines.forEach(line => { console.log(addFullWidthBackground(` ${line}`, '20;20;20', true)); }); console.log(addFullWidthBackground('', '20;20;20', true)); try { console.log(addFullWidthBackground(colors.cyan(` Fetching codes by @${cleanHandle}...`), '20;20;20', true)); console.log(addFullWidthBackground('', '20;20;20', true)); const userCodes = await fetchCodesByHandle(cleanHandle, limit); if (userCodes.length === 0) { console.log(addFullWidthBackground(colors.yellow(` No codes found for @${cleanHandle} in recent ${limit} codes`), '20;20;20', true)); console.log(addFullWidthBackground(colors.dim(` Note: Only recent codes are searchable (max 100)`), '20;20;20', true)); console.log(addFullWidthBackground(colors.dim(` Try a user with recent activity like @fifi`), '20;20;20', true)); console.log(addFullWidthBackground('', '20;20;20', true)); addBorder(); return; } const header = ` Found ${userCodes.length} code${userCodes.length === 1 ? '' : 's'} by @${cleanHandle}`; console.log(addFullWidthBackground(colors.green(header), '20;20;20', true)); console.log(addFullWidthBackground('', '20;20;20', true)); // Display each code with syntax highlighting for (let i = 0; i < userCodes.length; i++) { const codeData = userCodes[i]; const codeNum = `${i + 1}`.padStart(3, ' '); // Format timestamp to local time const timestamp = new Date(codeData.when); const localTime = timestamp.toLocaleString('en-US', { year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', second: '2-digit', hour12: false }); // Code header with piece name const codeName = formatPieceName(codeData.code, true); const codeHeader = ` ${colors.gray(`${codeNum}.`)} ${codeName} ${colors.dim(`• ${localTime}`)} ${colors.gray(`• ${codeData.hits || 0} hits`)}`; console.log(addFullWidthBackground(codeHeader, '20;20;20', true)); // URL const url = ` ${colors.dim(`https://aesthetic.computer/$${codeData.code}`)}`; console.log(addFullWidthBackground(url, '20;20;20', true)); // Syntax highlighted source const sourceLines = codeData.source.split('\n'); for (const line of sourceLines) { if (line.trim() === '') { console.log(addFullWidthBackground(' ', '20;20;20', true)); continue; } // Apply syntax highlighting const highlighted = syntaxHighlight(line); const indentedLine = ` ${highlighted}`; console.log(addFullWidthBackground(indentedLine, '20;20;20', true)); } // Separator between codes if (i < userCodes.length - 1) { console.log(addFullWidthBackground('', '20;20;20', true)); const separator = ` ${colors.gray('─'.repeat(60))}`; console.log(addFullWidthBackground(separator, '20;20;20', true)); console.log(addFullWidthBackground('', '20;20;20', true)); } } console.log(addFullWidthBackground('', '20;20;20', true)); } catch (error) { console.log(addFullWidthBackground(colors.red(` Error: ${error.message}`), '20;20;20', true)); console.log(addFullWidthBackground('', '20;20;20', true)); } finally { addBorder(); }}
function testColorConversions() { console.log('\n🔍 Color Conversion Debug:'); const testColors = ['white', 'black', 'gray', 'salmon', 'brown', 'palegreen', 'rainbow', 'red', 'orange']; for (const colorName of testColors) { // Test graph.findColor let rgba = null; if (graph && graph.findColor) { try { rgba = graph.findColor(colorName); } catch (e) { rgba = null; } } console.log(`\n${colorName}:`); console.log(` graph.findColor: ${rgba ? `RGB(${rgba.slice(0,3).join(', ')})` : 'not found'}`); // Test rgbToAnsi directly if (rgba && rgba.length >= 3) { const [r, g, b] = rgba; const ansiColor = rgbToAnsi(r, g, b); console.log(` terminal result: ${ansiColor}${colorName}${COLORS.reset}`); } // Test full KidLisp format conversion const testText = `\\${colorName}\\${colorName}`; const converted = convertKidlispColorsToAnsi(testText); console.log(` kidlisp format result: ${converted}`); }}
// Color test functionfunction testTerminalColors() { console.log('\n🎨 Terminal Color Support Test\n'); // Test 16 basic colors console.log('Basic 16 Colors:'); for (let i = 0; i < 16; i++) { process.stdout.write(`\x1b[48;5;${i}m ${i.toString().padStart(2)} \x1b[0m`); if ((i + 1) % 8 === 0) console.log(''); } // Test 216 color cube (6x6x6) console.log('\n216 Color Cube (6x6x6):'); for (let r = 0; r < 6; r++) { for (let g = 0; g < 6; g++) { for (let b = 0; b < 6; b++) { const color = 16 + (r * 36) + (g * 6) + b; process.stdout.write(`\x1b[48;5;${color}m \x1b[0m`); } process.stdout.write(' '); } console.log(''); } // Test 24 grayscale colors console.log('\nGrayscale (24 colors):'); for (let i = 232; i < 256; i++) { process.stdout.write(`\x1b[48;5;${i}m \x1b[0m`); } console.log(''); // Test RGB colors (if supported) console.log('\nTrue Color (24-bit RGB) Test:'); const rgbColors = [ [255, 0, 0], // Red [255, 165, 0], // Orange [255, 255, 0], // Yellow [0, 255, 0], // Green [0, 255, 255], // Cyan [0, 0, 255], // Blue [128, 0, 128], // Purple [255, 192, 203] // Pink ]; rgbColors.forEach(([r, g, b], i) => { process.stdout.write(`\x1b[48;2;${r};${g};${b}m RGB(${r},${g},${b}) \x1b[0m `); if ((i + 1) % 4 === 0) console.log(''); }); // Test KidLisp named colors console.log('\n\nKidLisp Named Colors Test:'); const kidlispColors = [ 'red', 'orange', 'yellow', 'lime', 'green', 'cyan', 'blue', 'purple', 'magenta', 'pink', 'white', 'gray', 'black', 'salmon', 'brown', 'tan', 'violet', 'indigo', 'navy', 'teal' ]; kidlispColors.forEach((colorName, i) => { const ansiCode = simpleColorToAnsi(colorName); process.stdout.write(`${ansiCode}${colorName}\x1b[0m `); if ((i + 1) % 5 === 0) console.log(''); }); console.log('\n\n💡 Tips:'); console.log('- If you see solid color blocks, your terminal supports 256 colors'); console.log('- If RGB colors look smooth, your terminal supports 24-bit true color'); console.log('- Modern terminals usually support 24-bit color (16.7M colors)'); console.log('- Check $COLORTERM environment variable for truecolor support'); console.log(`- Your COLORTERM: ${process.env.COLORTERM || 'not set'}`); console.log(`- Your TERM: ${process.env.TERM || 'not set'}`);}
// Main scriptasync function main() { const args = process.argv.slice(2); if (args.length === 0) { printUsage(); process.exit(1); } // Check for special commands if (args[0] === '--test-colors' || args[0] === 'test-colors') { testTerminalColors(); process.exit(0); } if (args[0] === '--debug-colors' || args[0] === 'debug-colors') { testColorConversions(); process.exit(0); } if (args[0] === '--test-css-colors' || args[0] === 'test-css-colors') { testCSSColorsMapping(); process.exit(0); } const pieceName = args[0]; // Check if it's a user handle request (starts with @) if (pieceName.startsWith('@')) { const handle = pieceName; const limit = args[1] ? parseInt(args[1]) : 1000; // Default to 1000 for handle searches try { await displayUserCodes(handle, limit); } catch (error) { console.error(colors.red(`Error: ${error.message}`)); } finally { process.exit(0); } return; } const showSource = true; // Always show source by default // Remove $ prefix if present for display const cleanName = pieceName.startsWith('$') ? pieceName.substring(1) : pieceName; // Create beautiful ASCII art title with gradients const asciiLines = generateAsciiArt('$' + cleanName); // Add top border addBorder(); console.log(addFullWidthBackground('', '20;20;20', true)); // Spacing with borders asciiLines.forEach(line => { console.log(addFullWidthBackground(` ${line}`, '20;20;20', true)); // 2-space indent with borders }); console.log(addFullWidthBackground('', '20;20;20', true)); // Single spacing line with borders try { // Build the tree await printTreeNode(pieceName, 0, "", showSource); } catch (error) { console.error(colors.red(`Error: ${error.message}`)); } finally { // Add bottom border console.log(addFullWidthBackground('', '20;20;20', true)); // Spacing with borders addBorder(); // Explicitly exit to prevent hanging process.exit(0); }}
main().catch((error) => { console.error(colors.red(`❌ Unhandled error: ${error.message}`)); process.exit(1);});