uwonbot 1.0.9 → 1.1.0

package/bin/uwonbot.js

@@ -13,7 +13,7 @@ showBanner();
 program
     .name('uwonbot')
     .description('Uwonbot AI Assistant — Your AI controls your computer')
-    .version('1.0.9');
+    .version('1.1.0');
 
 program
     .command('login')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uwonbot",
-  "version": "1.0.9",
+  "version": "1.1.0",
   "description": "Uwonbot AI Assistant CLI — Your AI controls your computer",
   "main": "src/index.js",
   "bin": {

package/src/chat.js

@@ -7,6 +7,7 @@ import open from 'open';
 import { getConfig } from './config.js';
 import { sendToBrain } from './brain.js';
 import { showMiniBar } from './banner.js';
+import { printOrb, animateOrb } from './terminalOrb.js';
 import {
     hasRegisteredDevices,
     createCLISession,
@@ -16,6 +17,40 @@ import {
 
 const WEB_APP_URL = 'https://chartapp-653e1.web.app';
 
+function hexToRgb(hex) {
+    const h = hex.replace('#', '');
+    return [
+        parseInt(h.substring(0, 2), 16) || 37,
+        parseInt(h.substring(2, 4), 16) || 99,
+        parseInt(h.substring(4, 6), 16) || 235,
+    ];
+}
+
+async function sleep(ms) {
+    return new Promise(r => setTimeout(r, ms));
+}
+
+async function bootSequence(assistant, brainLabel, brainColor) {
+    const c = chalk.hex(brainColor);
+    const g = chalk.gray;
+    const w = chalk.white;
+
+    const steps = [
+        [300, `${g('  [SYS]')}  ${w('INITIATING SYSTEM I...')}`],
+        [300, `${g('  [SYS]')}  ${c(`NETWARE ${assistant.name.toUpperCase()} v1.0`)}`],
+        [400, `${g('  [SYS]')}  ${w('PROTOCOL: SCANNING...')}`],
+        [300, `${g('  [SYS]')}  ${w('RELEASING CONFIGURATION')}`],
+        [200, `${g('  [SYS]')}  ${w(`Brain: ${brainLabel} | API: connected`)}`],
+        [200, `${g('  [SYS]')}  ${w('Authentication verified.')}`],
+        [500, `${g('  [SYS]')}  ${chalk.green('All systems operational. Standing by.')}`],
+    ];
+
+    for (const [delay, text] of steps) {
+        await sleep(delay);
+        console.log(text);
+    }
+}
+
 async function requireBiometricAuth(uid) {
     try {
         const hasDevices = await hasRegisteredDevices(uid);
@@ -107,12 +142,23 @@ export async function startChat(assistantName, assistant, initialCommand) {
         : assistant.brain === 'gemini' ? '#8b5cf6'
         : '#2563eb';
 
+    const orbColorHex = assistant.orbColor || brainColor;
+    const orbRgb = hexToRgb(orbColorHex);
+
+    console.clear();
+    printOrb({
+        radius: 10,
+        color: orbRgb,
+        label: assistant.name.toUpperCase(),
+        status: '준비됨',
+    });
+
+    await bootSequence(assistant, brainLabel, brainColor);
+
     console.log('');
-    console.log(chalk.hex('#2563eb')('  ╔══════════════════════════════════════════╗'));
-    console.log(chalk.hex('#2563eb')('  ║') + chalk.white.bold(`  ${assistant.avatar || '🤖'} ${assistant.name}`) + ' '.repeat(Math.max(1, 38 - assistant.name.length)) + chalk.hex('#2563eb')('║'));
-    console.log(chalk.hex('#2563eb')('  ║') + chalk.gray(`  Brain: `) + chalk.hex(brainColor)(brainLabel) + ' '.repeat(Math.max(1, 30 - brainLabel.length)) + chalk.hex('#2563eb')('║'));
-    console.log(chalk.hex('#2563eb')('  ║') + chalk.gray('  Type "exit" to quit, "clear" to reset   ') + chalk.hex('#2563eb')('║'));
-    console.log(chalk.hex('#2563eb')('  ╚══════════════════════════════════════════╝'));
+    console.log(chalk.gray('  ─────────────────────────────────────────'));
+    console.log(chalk.gray('  "exit" 종료 | "clear" 대화 초기화'));
+    console.log(chalk.gray('  ─────────────────────────────────────────'));
     console.log('');
 
     const messages = [];

package/src/terminalOrb.js

@@ -0,0 +1,232 @@
+import chalk from 'chalk';
+
+const SHADING_CHARS = ' .:-=+*#%@';
+
+/**
+ * Renders a 3D sphere in the terminal using ray-traced shading with true color.
+ * @param {object} opts
+ * @param {number} [opts.radius=10] - Sphere radius in character cells
+ * @param {number[]} [opts.color=[37,99,235]] - RGB base color
+ * @param {string} [opts.label] - Text label below the orb
+ * @param {string} [opts.status] - Status text below label
+ * @param {boolean} [opts.glow=true] - Enable glow effect
+ * @returns {string} The rendered orb as a string
+ */
+export function renderOrb(opts = {}) {
+    const radius = opts.radius || 10;
+    const [baseR, baseG, baseB] = opts.color || [37, 99, 235];
+    const label = opts.label || '';
+    const status = opts.status || '';
+    const glow = opts.glow !== false;
+
+    const width = radius * 2 + 4;
+    const height = radius + 2;
+    const lines = [];
+
+    const lightX = -0.4;
+    const lightY = -0.5;
+    const lightZ = 0.8;
+    const lightLen = Math.sqrt(lightX * lightX + lightY * lightY + lightZ * lightZ);
+    const lx = lightX / lightLen;
+    const ly = lightY / lightLen;
+    const lz = lightZ / lightLen;
+
+    for (let y = -radius; y <= radius; y++) {
+        let line = '';
+        const rowY = y / radius;
+
+        for (let x = -width / 2; x <= width / 2; x++) {
+            const rowX = x / (width / 2);
+            const distSq = rowX * rowX + rowY * rowY;
+
+            if (distSq > 1.0) {
+                if (glow && distSq < 1.5) {
+                    const glowIntensity = 1.0 - (distSq - 1.0) / 0.5;
+                    const gr = Math.round(baseR * glowIntensity * 0.3);
+                    const gg = Math.round(baseG * glowIntensity * 0.3);
+                    const gb = Math.round(baseB * glowIntensity * 0.3);
+                    line += chalk.rgb(gr, gg, gb)('·');
+                } else {
+                    line += ' ';
+                }
+                continue;
+            }
+
+            const nz = Math.sqrt(1 - distSq);
+            const nx = rowX;
+            const ny = rowY;
+
+            const diffuse = Math.max(0, nx * lx + ny * ly + nz * lz);
+
+            const rx = 2 * (nx * lx + ny * ly + nz * lz) * nx - lx;
+            const ry = 2 * (nx * lx + ny * ly + nz * lz) * ny - ly;
+            const rz = 2 * (nx * lx + ny * ly + nz * lz) * nz - lz;
+            const viewZ = 1.0;
+            const specular = Math.pow(Math.max(0, rz / Math.sqrt(rx * rx + ry * ry + rz * rz) * viewZ), 32);
+
+            const ambient = 0.12;
+            const intensity = Math.min(1.0, ambient + diffuse * 0.75 + specular * 0.5);
+
+            const r = Math.min(255, Math.round(baseR * intensity + specular * 180));
+            const g = Math.min(255, Math.round(baseG * intensity + specular * 180));
+            const b = Math.min(255, Math.round(baseB * intensity + specular * 180));
+
+            const charIdx = Math.min(SHADING_CHARS.length - 1, Math.round(intensity * (SHADING_CHARS.length - 1)));
+            const ch = SHADING_CHARS[charIdx];
+
+            line += chalk.rgb(r, g, b)(ch || ' ');
+        }
+        lines.push(line);
+    }
+
+    if (label) {
+        lines.push('');
+        const padded = label.length < width * 2
+            ? ' '.repeat(Math.max(0, Math.floor((width - label.length / 2)))) + label
+            : label;
+        lines.push(chalk.bold.white(padded));
+    }
+
+    if (status) {
+        const padded = status.length < width * 2
+            ? ' '.repeat(Math.max(0, Math.floor((width - status.length / 2)))) + status
+            : status;
+        lines.push(chalk.gray(padded));
+    }
+
+    return lines.join('\n');
+}
+
+/**
+ * Animated spinning orb in the terminal.
+ * @param {object} opts
+ * @param {number[]} [opts.color=[37,99,235]]
+ * @param {string} [opts.label]
+ * @param {string} [opts.status]
+ * @param {number} [opts.radius=10]
+ * @param {number} [opts.fps=12]
+ * @returns {{ update(opts), stop() }}
+ */
+export function animateOrb(opts = {}) {
+    const radius = opts.radius || 10;
+    const fps = opts.fps || 12;
+    let color = opts.color || [37, 99, 235];
+    let label = opts.label || '';
+    let statusText = opts.status || '';
+    let frame = 0;
+    let running = true;
+    const totalLines = (radius * 2 + 3) + (label ? 1 : 0) + (statusText ? 1 : 0) + 1;
+
+    function draw() {
+        const angle = (frame * 0.05);
+        const lightX = Math.cos(angle) * 0.6;
+        const lightY = -0.5;
+        const lightZ = Math.sin(angle) * 0.4 + 0.6;
+        const lightLen = Math.sqrt(lightX * lightX + lightY * lightY + lightZ * lightZ);
+
+        const width = radius * 2 + 4;
+        const lines = [];
+
+        for (let y = -radius; y <= radius; y++) {
+            let line = '  ';
+            const rowY = y / radius;
+
+            for (let x = -width / 2; x <= width / 2; x++) {
+                const rowX = x / (width / 2);
+                const distSq = rowX * rowX + rowY * rowY;
+
+                if (distSq > 1.0) {
+                    if (distSq < 1.4) {
+                        const glowIntensity = 1.0 - (distSq - 1.0) / 0.4;
+                        const pulse = 0.3 + Math.sin(frame * 0.15) * 0.1;
+                        const gr = Math.round(color[0] * glowIntensity * pulse);
+                        const gg = Math.round(color[1] * glowIntensity * pulse);
+                        const gb = Math.round(color[2] * glowIntensity * pulse);
+                        line += chalk.rgb(gr, gg, gb)('·');
+                    } else {
+                        line += ' ';
+                    }
+                    continue;
+                }
+
+                const nz = Math.sqrt(1 - distSq);
+                const nx = rowX;
+                const ny = rowY;
+
+                const lx = lightX / lightLen;
+                const ly = lightY / lightLen;
+                const lz = lightZ / lightLen;
+
+                const diffuse = Math.max(0, nx * lx + ny * ly + nz * lz);
+                const dot = nx * lx + ny * ly + nz * lz;
+                const rz = 2 * dot * nz - lz;
+                const specular = Math.pow(Math.max(0, rz), 40);
+
+                const ambient = 0.08;
+                const intensity = Math.min(1.0, ambient + diffuse * 0.7 + specular * 0.6);
+
+                const r = Math.min(255, Math.round(color[0] * intensity + specular * 200));
+                const g = Math.min(255, Math.round(color[1] * intensity + specular * 200));
+                const b = Math.min(255, Math.round(color[2] * intensity + specular * 200));
+
+                const charIdx = Math.min(SHADING_CHARS.length - 1, Math.round(intensity * (SHADING_CHARS.length - 1)));
+                line += chalk.rgb(r, g, b)(SHADING_CHARS[charIdx] || ' ');
+            }
+            lines.push(line);
+        }
+
+        if (label) {
+            lines.push('');
+            const pad = Math.max(0, Math.floor((width + 2 - label.length) / 2));
+            lines.push(' '.repeat(pad) + chalk.bold.white(label));
+        }
+        if (statusText) {
+            const pad = Math.max(0, Math.floor((width + 2 - statusText.length) / 2));
+            lines.push(' '.repeat(pad) + chalk.gray(statusText));
+        }
+
+        return lines.join('\n');
+    }
+
+    let prevLineCount = 0;
+
+    const interval = setInterval(() => {
+        if (!running) return;
+        frame++;
+
+        if (prevLineCount > 0) {
+            process.stdout.write(`\x1b[${prevLineCount}A\x1b[J`);
+        }
+
+        const output = draw();
+        process.stdout.write(output + '\n');
+        prevLineCount = output.split('\n').length;
+    }, 1000 / fps);
+
+    const output = draw();
+    process.stdout.write(output + '\n');
+    prevLineCount = output.split('\n').length;
+
+    return {
+        update(newOpts) {
+            if (newOpts.color) color = newOpts.color;
+            if (newOpts.label !== undefined) label = newOpts.label;
+            if (newOpts.status !== undefined) statusText = newOpts.status;
+        },
+        stop() {
+            running = false;
+            clearInterval(interval);
+        },
+    };
+}
+
+/**
+ * Prints a static orb once.
+ */
+export function printOrb(opts = {}) {
+    console.log('');
+    console.log(renderOrb(opts));
+    console.log('');
+}
+
+export default { renderOrb, animateOrb, printOrb };