dexterm-cli 0.1.2 → 0.1.3

package/dist/packages/voice/src/speakable.js

@@ -0,0 +1,111 @@
+// Make a line "speakable" like a trader, not digit by digit (task-1411). A tester heard Jarvis read a raw
+// per-token price ("zero point zero zero zero zero zero two nine") and big raw numbers, which sounds
+// crazy. This normaliser runs on EVERY spoken line (controller.speak) and applies these rules, in order:
+//
+//   1. Tiny per-token prices are NEVER read digit by digit. A sub-cent decimal ($0.0000029), the app's
+//      own subscript rendering ($0.0₅29), or any value below a cent becomes the coin's MARKET CAP when
+//      the line (or the caller) knows it, else the phrase "a tiny price". We NEVER invent a number.
+//      A sub-cent value that is an AMOUNT of something (e.g. "0.005 SOL", "0.0025 SOL fee") is left
+//      alone — it is a quantity, not a per-token price.
+//   2. Big raw numbers become human words: 340000 → "340 thousand", 1200000 → "1.2 million",
+//      4500000000 → "4.5 billion". Word boundaries keep digits inside an address untouched, and a bare
+//      4-digit YEAR (1900–2099) is left as-is so "launched in 2024" never reads "launched in 2 thousand".
+//   3. Percentages read naturally: "12%" → "12 percent".
+//
+// Pure and dependency-free so every rule is unit-tested without spawning a voice.
+const SUBSCRIPT = '₀₁₂₃₄₅₆₇₈₉'; // ₀..₉
+// Units that follow a small decimal and mark it as an AMOUNT, not a per-token price (so "0.005 SOL" is
+// a quantity we read normally). Case-insensitive, whole word.
+const AMOUNT_UNIT = /^\s*(sol|eth|btc|usdc|usdt|tokens?|coins?)\b/i;
+/** Round to one decimal and drop a trailing ".0" so "1.0 million" reads "1 million". */
+function trimNum(n) {
+    const r = Math.round(n * 10) / 10;
+    return (Number.isInteger(r) ? String(r) : r.toFixed(1));
+}
+/** A raw number (>= 1000) as human words: "340 thousand", "1.2 million", "4.5 billion". */
+export function humanizeNumber(n) {
+    const abs = Math.abs(n);
+    if (abs >= 1e9)
+        return `${trimNum(n / 1e9)} billion`;
+    if (abs >= 1e6)
+        return `${trimNum(n / 1e6)} million`;
+    if (abs >= 1e3)
+        return `${trimNum(n / 1e3)} thousand`;
+    return trimNum(n);
+}
+/** A number is a 4-digit calendar year (1900–2099): spoken as-is, never "2 thousand twenty four". */
+function isYear(v) {
+    return Number.isInteger(v) && v >= 1900 && v <= 2099;
+}
+/**
+ * Read a market cap out of the analyst line, e.g. "market cap $340K", "mcap of 1.2M", "cap: 340000",
+ * returned as a human phrase ("340 thousand"). The brief: a tiny price is replaced WITH THE COIN'S
+ * MARKET CAP WHEN THE ANALYST TEXT INCLUDES IT. Returns null when the line names no market cap.
+ */
+function marketCapFromText(text) {
+    const m = /\b(?:market\s*cap|mcap|m\.?c\.?|cap)\b[^$\d]{0,8}\$?([\d,]+(?:\.\d+)?)\s*([KkMmBb])?\b/.exec(text);
+    if (!m)
+        return null;
+    let v = parseFloat(m[1].replace(/,/g, ''));
+    if (!Number.isFinite(v))
+        return null;
+    const suf = m[2];
+    if (suf)
+        v *= /[Kk]/.test(suf) ? 1e3 : /[Mm]/.test(suf) ? 1e6 : 1e9;
+    if (v < 1000)
+        return null; // "cap 2 holders" etc. is not a market cap
+    return humanizeNumber(v);
+}
+/**
+ * Normalise a spoken line. `opts.marketCap`, when given, is the human market-cap phrase substituted for
+ * a tiny per-token price; otherwise speakable reads a market cap out of the line, and failing that uses
+ * "a tiny price" (never a made-up number).
+ */
+export function speakable(text, opts = {}) {
+    let s = String(text ?? '');
+    const mcap = (opts.marketCap && opts.marketCap.trim()) || marketCapFromText(s);
+    const tiny = mcap ? `a market cap of ${String(mcap).trim()}` : 'a tiny price';
+    // 1a. Subscript price forms the app renders, e.g. "$0.0₅29" / "0.0₄1686" — never read the digits.
+    s = s.replace(new RegExp(`\\$?\\d*\\.?\\d*[${SUBSCRIPT}]+[${SUBSCRIPT}0-9]*`, 'g'), tiny);
+    // 1b. Sub-cent decimal prices, e.g. "$0.0000029", "0.00004". A value below a cent is a per-token price,
+    //     not an amount; the leading-zeros case (>=2 zeros after the point) is always a price — UNLESS it
+    //     is immediately followed by a unit word (SOL/ETH/tokens…), in which case it is an AMOUNT: leave it.
+    s = s.replace(/\$?\d*\.\d+/g, (m, idx, full) => {
+        const v = parseFloat(m.replace(/[$,]/g, ''));
+        if (!Number.isFinite(v))
+            return m;
+        const after = full.slice(idx + m.length);
+        if (AMOUNT_UNIT.test(after))
+            return m; // "0.005 SOL" is a quantity, not a per-token price
+        if (/\.0{2,}/.test(m) || (v > 0 && v < 0.01))
+            return tiny;
+        return m;
+    });
+    // 2. Percentages read as words before the big-number pass (so "12%" isn't seen as a bare number).
+    s = s.replace(/(\d+(?:\.\d+)?)\s*%/g, '$1 percent');
+    // 2b. Abbreviated magnitudes the app and analysts use: "$340K" / "2.1M" / "4.5B" → words. Lowercase
+    //     "m" is intentionally EXCLUDED: "15m" / "6h" are a token's AGE (minutes), not millions.
+    s = s.replace(/\$?(\d+(?:\.\d+)?)\s*([KkMBb])\b/g, (_m, num, suf) => {
+        const word = /[Kk]/.test(suf) ? 'thousand' : suf === 'M' ? 'million' : 'billion';
+        return `${num} ${word}`;
+    });
+    // 3. Big raw numbers -> human words. `\b` keeps runs of digits inside an address/word untouched, and a
+    //    number already followed by a scale word (k/m/b/thousand/…) or "percent" is left alone, as is a
+    //    bare 4-digit year.
+    s = s.replace(/\$?\b\d{1,3}(?:,\d{3})+(?:\.\d+)?\b|\$?\b\d{4,}(?:\.\d+)?\b/g, (m, ...rest) => {
+        const full = rest[rest.length - 1]; // the whole input string
+        const idx = rest[rest.length - 2];
+        const after = full.slice(idx + m.length).trimStart().toLowerCase();
+        if (/^(k|m|b|bn|thousand|million|billion|percent|%)\b/.test(after))
+            return m;
+        const v = parseFloat(m.replace(/[$,]/g, ''));
+        if (!Number.isFinite(v) || Math.abs(v) < 1000)
+            return m;
+        // A bare 4-digit year ("launched in 2024") stays a year; a dollar-prefixed or comma-grouped number
+        // ("$2024", "2,024") is a real amount and is humanised.
+        if (isYear(v) && !/[$,]/.test(m))
+            return m;
+        return humanizeNumber(v);
+    });
+    return s;
+}

package/dist/packages/voice/src/tts/piper-setup.js

@@ -0,0 +1,229 @@
+// Managed Piper runtime for macOS (task-1416). The prebuilt macOS Piper tarball from rhasspy is BROKEN
+// (it needs a libespeak-ng dylib it does not bundle), so on macOS dexterm builds its own private Python
+// runtime instead: a virtualenv at `~/.dexterm/piper/venv` with `pip install piper-tts`, plus the
+// checksum-verified en_GB-alan-medium voice model. After setup the voice runs fully OFFLINE, needs no
+// key, and is driven by `<venv>/bin/python -m piper` (see piper.ts resolvePiperRuntime).
+//
+// Everything that touches the system (running python/pip, the network) is INJECTED, so this module is
+// unit-testable with fakes and never spawns or downloads in tests. `dexterm voice setup` wires the real
+// child_process + global fetch (see packages/cli/src/voice-cmd.ts).
+//
+// Hosts contacted, ONLY while the user runs setup (documented on the site trust page):
+//   - https://pypi.org + https://files.pythonhosted.org  (pip resolves + downloads the piper-tts wheel and its deps)
+//   - https://huggingface.co                             (the voice model, via the existing checksum-verified downloader)
+import { existsSync, mkdirSync, rmSync, writeFileSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { downloadModel, modelRegistry, modelStatus } from "../download.js";
+/** Pinned piper-tts version (verified working on macOS/Python 3.9 in task-1416). */
+export const PIPER_PYPI_VERSION = '1.8.0';
+/** The minimum Python the managed runtime needs (piper-tts wheels + onnxruntime). */
+export const MIN_PYTHON = [3, 9];
+/** Paths inside the managed runtime, derived from the dexterm home. */
+export function piperRuntimePaths(home) {
+    const dir = join(home, 'piper');
+    const venv = join(dir, 'venv');
+    const binDir = process.platform === 'win32' ? 'Scripts' : 'bin';
+    const exe = process.platform === 'win32' ? '.exe' : '';
+    return {
+        dir,
+        venv,
+        python: join(venv, binDir, `python${exe}`),
+        pip: join(venv, binDir, `pip${exe}`),
+        record: join(dir, 'runtime.json'),
+    };
+}
+/** Parse "Python 3.11.7" → [3, 11, 7]; null when it does not look like a version. */
+export function parsePythonVersion(s) {
+    const m = s.match(/Python\s+(\d+)\.(\d+)(?:\.(\d+))?/i);
+    if (!m)
+        return null;
+    return [Number(m[1]), Number(m[2]), Number(m[3] ?? 0)];
+}
+/** True when a parsed version is at least MIN_PYTHON. */
+export function pythonVersionOk(v) {
+    if (!v)
+        return false;
+    if (v[0] !== MIN_PYTHON[0])
+        return v[0] > MIN_PYTHON[0];
+    return v[1] >= MIN_PYTHON[1];
+}
+/** The exact fix line shown when no suitable python3 is found (platform-specific). */
+export function pythonFixLine(platform = process.platform) {
+    if (platform === 'darwin') {
+        return 'Install Python 3.9+ : `brew install python@3.12` (Homebrew) or the Xcode Command Line Tools (`xcode-select --install`), then re-run `dexterm voice setup`.';
+    }
+    if (platform === 'win32') {
+        return 'Install Python 3.9+ from python.org (or `winget install Python.Python.3.12`), then re-run `dexterm voice setup`.';
+    }
+    return 'Install Python 3.9+ and venv: `sudo apt install python3 python3-venv` (Debian/Ubuntu), then re-run `dexterm voice setup`.';
+}
+/** The default python executables to probe, best-first. The CLI passes this (and may prepend DEXTERM_PYTHON). */
+export const DEFAULT_PYTHON_CANDIDATES = [
+    'python3.13', 'python3.12', 'python3.11', 'python3.10', 'python3.9', 'python3', 'python',
+];
+/** Find the first candidate whose `--version` is >= 3.9. Returns the executable + parsed version, or null. */
+export async function detectPython(deps) {
+    const seen = new Set();
+    for (const cand of deps.pythonCandidates ?? DEFAULT_PYTHON_CANDIDATES) {
+        if (!cand || seen.has(cand))
+            continue;
+        seen.add(cand);
+        let res;
+        try {
+            res = await deps.run(cand, ['--version']);
+        }
+        catch {
+            continue;
+        }
+        const v = parsePythonVersion(`${res.stdout} ${res.stderr}`.trim());
+        if (res.code === 0 && pythonVersionOk(v))
+            return { python: cand, version: v };
+    }
+    return null;
+}
+/** Read the managed-runtime record, or null when it is absent/invalid. */
+export function readRuntimeRecord(home) {
+    const { record } = piperRuntimePaths(home);
+    try {
+        return JSON.parse(readFileSync(record, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+/** Inspect the managed runtime WITHOUT touching python or the network (for `voice status` / the doctor). */
+export async function piperRuntimeStatus(home) {
+    const paths = piperRuntimePaths(home);
+    const model = await modelStatus(modelRegistry(home)['piper-voice']);
+    return {
+        installed: existsSync(paths.python) && model.installed,
+        python: paths.python,
+        pythonPresent: existsSync(paths.python),
+        modelInstalled: model.installed,
+        record: readRuntimeRecord(home),
+    };
+}
+/**
+ * Build the managed Piper runtime: detect python3 → confirm once → create the venv → `pip install
+ * piper-tts` (pinned, wheels only) → download + verify the voice model → write the record. Idempotent:
+ * returns 'already' without prompting when the venv python, piper-tts, and the model are all present.
+ * Any failure is reported (never thrown) with a copy-pasteable fix.
+ */
+export async function setupPiperRuntime(deps) {
+    const log = deps.log ?? (() => { });
+    const now = deps.now ?? Date.now;
+    const paths = piperRuntimePaths(deps.home);
+    const piperVoice = modelRegistry(deps.home)['piper-voice'];
+    // Already fully installed? Verify piper-tts imports too, so a half-built venv is repaired.
+    if (existsSync(paths.python) && (await modelStatus(piperVoice)).installed) {
+        const check = await deps.run(paths.python, ['-c', 'import piper']);
+        if (check.code === 0) {
+            log('Piper runtime is already installed and verified.');
+            return { status: 'already', python: paths.python, model: piperVoice.files.map((f) => f.dest) };
+        }
+    }
+    const found = await detectPython(deps);
+    if (!found)
+        return { status: 'no-python', fix: pythonFixLine() };
+    const versionStr = found.version.join('.');
+    const prompt = [
+        'Set up the neural voice (Piper en_GB-alan-medium). This will, only now:',
+        `  • create a private Python environment at ${paths.venv}`,
+        `  • pip install piper-tts==${PIPER_PYPI_VERSION} (wheels only) from pypi.org / files.pythonhosted.org`,
+        `  • download the ~61 MB voice model from huggingface.co (checksum-verified)`,
+        'It runs fully offline afterwards, needs no key, and `dexterm voice uninstall` removes it. Proceed?',
+    ].join('\n');
+    if (!(await deps.confirm(prompt))) {
+        log('Cancelled — nothing installed.');
+        return { status: 'cancelled' };
+    }
+    // 1. venv
+    try {
+        mkdirSync(paths.dir, { recursive: true });
+    }
+    catch { /* reported by the venv step if it matters */ }
+    if (!existsSync(paths.python)) {
+        log(`  • creating the Python environment (${found.python} ${versionStr})…`);
+        const venv = await deps.run(found.python, ['-m', 'venv', paths.venv]);
+        if (venv.code !== 0 || !existsSync(paths.python)) {
+            return { status: 'failed', python: found.python, pythonVersion: versionStr,
+                fix: `Creating the venv failed: ${(venv.stderr || venv.stdout).slice(-300).trim() || 'unknown error'}. On Debian/Ubuntu install \`python3-venv\` and re-run \`dexterm voice setup\`.` };
+        }
+    }
+    // 2. pip install piper-tts (pinned, wheels only so there is never a source build / compiler requirement)
+    log(`  • installing piper-tts==${PIPER_PYPI_VERSION} (this downloads a few wheels)…`);
+    const pip = await deps.run(paths.python, ['-m', 'pip', 'install', '--disable-pip-version-check', '--only-binary', ':all:', `piper-tts==${PIPER_PYPI_VERSION}`]);
+    if (pip.code !== 0) {
+        return { status: 'failed', python: found.python, pythonVersion: versionStr,
+            fix: `pip install failed: ${(pip.stderr || pip.stdout).slice(-300).trim() || 'unknown error'}. Check your network and that a wheel exists for this Python, then re-run \`dexterm voice setup\`.` };
+    }
+    const imp = await deps.run(paths.python, ['-c', 'import piper']);
+    if (imp.code !== 0) {
+        return { status: 'failed', python: found.python, pythonVersion: versionStr,
+            fix: `piper-tts installed but does not import: ${(imp.stderr || imp.stdout).slice(-300).trim() || 'unknown error'}.` };
+    }
+    // 3. model (reuse the checksum-verified downloader; setup already confirmed, so do not prompt again)
+    let dl;
+    try {
+        const download = deps.downloadModelImpl ?? downloadModel;
+        dl = await download(piperVoice, { confirm: () => Promise.resolve(true), log, fetchImpl: deps.fetchImpl });
+    }
+    catch (e) {
+        return { status: 'failed', python: found.python, pythonVersion: versionStr,
+            fix: `Voice model download failed: ${e.message}. Re-run \`dexterm voice setup\` (it resumes) once your network is back.` };
+    }
+    // 4. record
+    const record = {
+        kind: 'venv',
+        piperTts: PIPER_PYPI_VERSION,
+        python: paths.python,
+        pythonVersion: versionStr,
+        model: piperVoice.files[0].dest,
+        platform: process.platform,
+        installedAt: new Date(now()).toISOString(),
+    };
+    try {
+        writeFileSync(paths.record, JSON.stringify(record, null, 2) + '\n', { mode: 0o600 });
+    }
+    catch { /* non-fatal */ }
+    log('Neural voice ready. It is now the default speaking voice (fallback: the system voice).');
+    return { status: 'ok', python: found.python, pythonVersion: versionStr, model: dl.files };
+}
+/**
+ * Remove the managed Piper runtime (the venv + its record). The downloaded voice model is LEFT in place
+ * by default because it is shared with `dexterm voice download piper-voice` and the Linux binary path;
+ * pass `purgeModel` to delete it too.
+ */
+export async function uninstallPiperRuntime(home, opts = {}) {
+    const paths = piperRuntimePaths(home);
+    const removed = [];
+    let found = false;
+    for (const p of [paths.venv, paths.record]) {
+        if (existsSync(p)) {
+            found = true;
+            try {
+                rmSync(p, { recursive: true, force: true });
+                removed.push(p);
+            }
+            catch { /* ignore */ }
+        }
+    }
+    if (opts.purgeModel) {
+        for (const f of modelRegistry(home)['piper-voice'].files) {
+            if (existsSync(f.dest)) {
+                found = true;
+                try {
+                    rmSync(f.dest, { force: true });
+                    removed.push(f.dest);
+                }
+                catch { /* ignore */ }
+            }
+        }
+    }
+    // Remove the now-empty piper dir if nothing else lives in it.
+    try {
+        rmSync(paths.dir, { recursive: false });
+    }
+    catch { /* not empty / absent — fine */ }
+    return { status: found ? 'ok' : 'absent', removed };
+}