@ciphore/radiocli 0.2.2 → 0.2.3

package/dist/ui/visualizers/receiver-visualizers.js

@@ -1,6 +1,8 @@
 import { themeAccent, themeContributionColors } from '../theme.js';
+import { retroReceiverBuilders } from './retro-receivers.js';
 import { receiverStyleMetadata } from './receiver-style-registry.js';
 const receiverStyleBuilders = {
+    ...retroReceiverBuilders,
     ultracode: buildUltracode,
     'motion-contour': buildMotionContour,
     leds: buildLeds,
@@ -89,6 +91,7 @@ function buildMicroVisualizer(style, pulse, width, height, theme) {
 // the circular braille rings) while fixed-size and minimum-size scenes use the
 // supersampled fit path below.
 const microNativeScaleStyles = new Set([
+    ...Object.keys(retroReceiverBuilders),
     'pulse-grid',
     'hex-pulse',
     'galaxy',

package/dist/ui/visualizers/retro-receivers.js

@@ -0,0 +1,4 @@
+import { terminalReceiverBuilders } from './terminal-receivers.js';
+export const retroReceiverBuilders = {
+    ...terminalReceiverBuilders
+};

package/dist/ui/visualizers/terminal-receivers.js

@@ -0,0 +1,57 @@
+import { buildGallopFine } from './gallop.js';
+import { panelBackground, themeAccent, themeContributionColors } from '../theme.js';
+const clamp = (n) => Math.max(0, Math.min(1, n));
+function blend(a, b, t) {
+    return '#' + [1, 3, 5].map(offset => Math.round(parseInt(a.slice(offset, offset + 2), 16) * (1 - t) + parseInt(b.slice(offset, offset + 2), 16) * t).toString(16).padStart(2, '0')).join('');
+}
+/** A cell canvas, not a bitmap: glyphs, whole-cell color and intentional empty space. */
+function canvas(width, height, theme) {
+    const w = Math.max(1, Math.floor(width));
+    const h = Math.max(1, Math.floor(height));
+    const accent = themeAccent(theme);
+    const contributions = themeContributionColors(theme);
+    const ramp = [panelBackground, blend(panelBackground, contributions[1], 0.55),
+        ...contributions.slice(1), blend(accent, '#ffffff', 0.36), '#ffffff'];
+    const cells = Array.from({ length: h }, () => Array.from({ length: w }, () => ({ text: ' ', color: accent })));
+    const paint = (x, y, text, level, background = false, color) => {
+        const row = Math.round(y);
+        const col = Math.round(x);
+        if (row < 0 || row >= h || col < 0 || col >= w)
+            return;
+        const ink = color ?? ramp[Math.max(0, Math.min(ramp.length - 1, Math.round(level)))];
+        cells[row][col] = background ? { text: ' ', color: ink, backgroundColor: ink } : { text, color: ink };
+    };
+    const finish = () => cells.map(row => {
+        const segments = [];
+        for (const cell of row) {
+            const last = segments.at(-1);
+            if (last && last.color === cell.color && last.backgroundColor === cell.backgroundColor)
+                last.text += cell.text;
+            else
+                segments.push({ ...cell });
+        }
+        return { text: row.map(c => c.text).join(''), color: accent, segments };
+    });
+    return { w, h, ramp, paint, finish };
+}
+// Interleaved wavefronts, folded through each other. Entire cells are the light source.
+const crossfade = (pulse, width, height, theme) => {
+    const c = canvas(width, height, theme);
+    const t = pulse * 0.08;
+    const shades = Array.from({ length: 18 }, (_, i) => blend(c.ramp[2], c.ramp[5], i / 17));
+    for (let y = 0; y < c.h; y++) {
+        for (let x = 0; x < c.w; x++) {
+            const u = x / c.w * 2 - 1;
+            const v = y / c.h * 2 - 1;
+            const a = u * 8.5 + v * 3 + Math.sin(v * 3.4 - t * 0.7) * 2 - t * 1.1;
+            const b = v * 5 - u * 2 + Math.sin(u * 3 + t * 0.5) * 1.5 + t * 0.75;
+            const value = clamp(0.5 + 0.28 * Math.cos(a) + 0.24 * Math.cos(b));
+            c.paint(x, y, ' ', 0, true, shades[Math.round(value * 17)]);
+        }
+    }
+    return c.finish();
+};
+export const terminalReceiverBuilders = {
+    crossfade,
+    'gallop-fine': buildGallopFine
+};

package/dist/update-check.js

@@ -40,17 +40,26 @@ export function shouldCheckForUpdate(updateCheck, now = Date.now()) {
     const checkedAt = Date.parse(updateCheck.checkedAt);
     return !Number.isFinite(checkedAt) || now - checkedAt >= UPDATE_CHECK_INTERVAL_MS;
 }
-export function updateStatusText(updateCheck) {
+export function automaticUpdateChecksAllowed(enabled = true) {
+    return enabled && process.env.RADIOCLI_DISABLE_UPDATE_CHECK !== '1' && process.env.CI !== 'true';
+}
+export function updateAvailableForVersion(updateCheck, currentVersion = updateCheck?.currentVersion) {
+    return Boolean(updateCheck?.updateAvailable &&
+        updateCheck.latestVersion &&
+        currentVersion &&
+        compareSemver(updateCheck.latestVersion, currentVersion) > 0);
+}
+export function updateStatusText(updateCheck, currentVersion) {
     if (!updateCheck) {
         return 'not checked yet';
     }
-    if (updateCheck.updateAvailable && updateCheck.latestVersion) {
+    if (updateAvailableForVersion(updateCheck, currentVersion) && updateCheck.latestVersion) {
         return `v${updateCheck.latestVersion} available`;
     }
     if (updateCheck.error) {
         return `check failed: ${updateCheck.error}`;
     }
-    return updateCheck.latestVersion ? `current at v${updateCheck.latestVersion}` : 'not checked yet';
+    return updateCheck.latestVersion ? `current at v${currentVersion ?? updateCheck.latestVersion}` : 'not checked yet';
 }
 export function updateCommandForInstall(entryPath = process.argv[1]) {
     const resolved = resolvePath(entryPath);
@@ -58,16 +67,21 @@ export function updateCommandForInstall(entryPath = process.argv[1]) {
     if (/\/(?:opt\/homebrew|usr\/local)\/(?:Cellar|Homebrew)\//.test(haystack) || /\/\.linuxbrew\/(?:Cellar|Homebrew)\//.test(haystack)) {
         return { method: 'homebrew', command: 'brew update && brew upgrade radiocli' };
     }
-    if (/\/node_modules\/@ciphore\/radiocli\//.test(haystack)) {
+    if (/[\\/](?:pnpm|\.pnpm-global)[\\/]/.test(haystack)) {
+        return { method: 'pnpm', command: 'pnpm add -g @ciphore/radiocli@latest' };
+    }
+    if (/[\\/]\.bun[\\/]install[\\/]global[\\/]/.test(haystack)) {
+        return { method: 'bun', command: 'bun add -g @ciphore/radiocli@latest' };
+    }
+    if (/[\\/]node_modules[\\/]@ciphore[\\/]radiocli[\\/]/.test(haystack)) {
         return { method: 'npm', command: 'npm install -g @ciphore/radiocli@latest' };
     }
     return { method: 'unknown', command: 'npm install -g @ciphore/radiocli@latest' };
 }
 export function installUpdate(command = updateCommandForInstall().command) {
     return new Promise(resolve => {
-        const shell = process.platform === 'win32' ? 'cmd.exe' : 'sh';
-        const args = process.platform === 'win32' ? ['/d', '/s', '/c', command] : ['-lc', command];
-        const child = spawn(shell, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+        const shell = updateShellForPlatform(process.platform, command);
+        const child = spawn(shell.command, shell.args, { stdio: ['ignore', 'pipe', 'pipe'] });
         const chunks = [];
         child.stdout.on('data', chunk => chunks.push(Buffer.from(chunk)));
         child.stderr.on('data', chunk => chunks.push(Buffer.from(chunk)));
@@ -80,6 +94,11 @@ export function installUpdate(command = updateCommandForInstall().command) {
         });
     });
 }
+export function updateShellForPlatform(platform, command) {
+    return platform === 'win32'
+        ? { command: 'cmd.exe', args: ['/d', '/s', '/c', command] }
+        : { command: 'sh', args: ['-lc', command] };
+}
 export function compareSemver(left, right) {
     const leftParts = semverParts(left);
     const rightParts = semverParts(right);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ciphore/radiocli",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "A terminal-first world radio receiver built with Ink, mpv, and resilient public-radio providers.",
   "type": "module",
   "license": "MIT",
@@ -61,13 +61,16 @@
     "prepublishOnly": "npm run check && npm run lint && npm run test && npm run smoke:data && npm run fresh:check && npm run check:package",
     "pack:check": "npm pack --dry-run",
     "smoke:data": "tsx src/smoke/data-smoke.ts",
+    "smoke:mcp": "node scripts/mcp-smoke.mjs",
     "smoke:playback": "tsx src/smoke/playback-smoke.ts",
     "demo:script": "node scripts/demo-script.mjs",
     "demo:assets": "node scripts/capture-demo-assets.mjs",
     "fresh:check": "node scripts/fresh-check.mjs"
   },
   "dependencies": {
+    "@modelcontextprotocol/server": "^2.0.0",
     "ink": "^7.0.5",
+    "jsonc-parser": "^3.3.1",
     "react": "^19.2.6",
     "zod": "^4.4.3"
   },