@illuminis/comprism 0.1.4 → 0.1.5

package/out/lib/ui.js

@@ -19,6 +19,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LiveIndicator = exports.c = void 0;
 exports.width = width;
 exports.spectrumAt = spectrumAt;
+exports.pixelArt = pixelArt;
 exports.prismRule = prismRule;
 exports.banner = banner;
 exports.money = money;
@@ -86,6 +87,39 @@ function spectrumAt(index, glyph) {
     const [r, g, b] = SPECTRUM[Math.abs(index) % SPECTRUM.length];
     return `\x1b[38;2;${r};${g};${b}m${glyph}\x1b[0m`;
 }
+/**
+ * A small picture, drawn two pixels to a character with the half block glyph:
+ * the top pixel is the glyph's color and the bottom one its background, which
+ * makes each pixel square in an ordinary terminal font. Each row of `pixels`
+ * is six hex digits per pixel, `......` for a clear one, and two rows make one
+ * line. Returns nothing without color, because the picture is only color.
+ */
+function pixelArt(pixels) {
+    if (!useColorNow())
+        return [];
+    const at = (row, x) => {
+        const hex = row?.slice(x * 6, x * 6 + 6);
+        return !hex || hex === '......' ? null
+            : [0, 2, 4].map((k) => parseInt(hex.slice(k, k + 2), 16)).join(';');
+    };
+    const lines = [];
+    for (let y = 0; y < pixels.length; y += 2) {
+        let line = '';
+        for (let x = 0; x < (pixels[y]?.length ?? 0) / 6; x++) {
+            const top = at(pixels[y], x), bottom = at(pixels[y + 1], x);
+            if (top && bottom)
+                line += `\x1b[38;2;${top}m\x1b[48;2;${bottom}m▀\x1b[0m`;
+            else if (top)
+                line += `\x1b[38;2;${top}m▀\x1b[0m`;
+            else if (bottom)
+                line += `\x1b[38;2;${bottom}m▄\x1b[0m`;
+            else
+                line += ' ';
+        }
+        lines.push(line);
+    }
+    return lines;
+}
 function prismRule(w = width()) {
     if (!useColorNow())
         return '-'.repeat(w);

package/out/lib/voice.d.ts

@@ -34,6 +34,42 @@ export interface Recording {
  * headed off with `missing` so the person gets a sentence rather than an error.
  */
 export declare function start(): Recording;
+/** Live dictation in progress, on the Mac's own recogniser. */
+export interface LiveDictation {
+    /** The loudness now, 0 to 1. */
+    level: () => number;
+    /** The words so far. */
+    words: () => string;
+    /** Stop listening and get the final words, or null when it could not listen. */
+    stop: () => Promise<string | null>;
+    /** Why it could not listen, when it could not. */
+    problem: () => string;
+}
+/**
+ * Words as they are spoken, the way the web app shows them.
+ *
+ * Nothing is recorded to a file and nothing leaves the machine: the Mac's own
+ * recogniser listens and reports what it hears, several times a second.
+ * Returns null where there is no helper, and the caller records and has the
+ * server write it down instead, as before.
+ */
+export declare function listenLive(language?: string): LiveDictation | null;
+/**
+ * How loud the last tenth of a second was, from 0 to 1.
+ *
+ * Read off the file as it is written, so somebody speaking sees the meter move
+ * and knows they are being heard, before a single word has come back. Sixteen
+ * bit mono at 16 kHz is 3,200 bytes a tenth of a second.
+ */
+export declare function level(file: string): number;
+/**
+ * What has been said so far, as a WAV file a transcriber can read.
+ *
+ * The recorder writes the header's lengths only when it stops, so a copy taken
+ * mid recording claims no audio at all. The copy gets the lengths of what is
+ * actually there. Returns null until there is at least half a second to send.
+ */
+export declare function soFar(file: string): string | null;
 /** Delete the recording and the folder holding it. Always, and immediately. */
 export declare function discard(file: string): void;
 /**

package/out/lib/voice.js

@@ -36,6 +36,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.recorder = recorder;
 exports.missing = missing;
 exports.start = start;
+exports.listenLive = listenLive;
+exports.level = level;
+exports.soFar = soFar;
 exports.discard = discard;
 exports.transcribe = transcribe;
 /**
@@ -102,7 +105,9 @@ const RECORDERS = [
             ...(process.platform === 'darwin'
                 ? ['-f', 'avfoundation', '-i', ':default']
                 : ['-f', 'alsa', '-i', 'default']),
-            '-ac', '1', '-ar', RATE, '-y', out,
+            // Written as it is heard, not held until the end, so the meter and the
+            // words so far have something to read while the person is speaking.
+            '-ac', '1', '-ar', RATE, '-flush_packets', '1', '-y', out,
         ],
     },
     // Linux's own, present on most desktop installs.
@@ -206,6 +211,136 @@ function start() {
     };
     return { file, by: tool.name, stop };
 }
+/** The helper built beside this file on a Mac, when there is one. */
+function helper() {
+    if (process.platform !== 'darwin')
+        return null;
+    const p = path.join(__dirname, '..', 'native', 'dictate');
+    return fs.existsSync(p) ? p : null;
+}
+/**
+ * Words as they are spoken, the way the web app shows them.
+ *
+ * Nothing is recorded to a file and nothing leaves the machine: the Mac's own
+ * recogniser listens and reports what it hears, several times a second.
+ * Returns null where there is no helper, and the caller records and has the
+ * server write it down instead, as before.
+ */
+function listenLive(language = 'en-US') {
+    const bin = helper();
+    if (!bin)
+        return null;
+    const child = (0, node_child_process_1.spawn)(bin, [language], { stdio: ['pipe', 'pipe', 'ignore'] });
+    let loud = 0;
+    let heard = '';
+    let final = null;
+    let why = '';
+    let rest = '';
+    const ended = new Promise((resolve) => child.once('close', () => resolve()));
+    child.stdout?.on('data', (chunk) => {
+        rest += chunk.toString('utf8');
+        const lines = rest.split('\n');
+        rest = lines.pop() ?? '';
+        for (const line of lines) {
+            const kind = line.slice(0, 1);
+            const text = line.slice(2);
+            if (kind === 'L')
+                loud = Number(text) || 0;
+            else if (kind === 'P')
+                heard = text;
+            else if (kind === 'F')
+                final = text;
+            else if (kind === 'E')
+                why = text;
+        }
+    });
+    // The helper never outlives the session.
+    const abandon = () => { try {
+        child.kill('SIGKILL');
+    }
+    catch { /* gone */ } };
+    process.once('exit', abandon);
+    return {
+        level: () => loud,
+        words: () => heard,
+        problem: () => why,
+        stop: async () => {
+            // Closing its input is "Enter was pressed": it says its final words and ends.
+            try {
+                child.stdin?.end();
+            }
+            catch { /* gone */ }
+            const timeout = new Promise((resolve) => setTimeout(resolve, 4000).unref());
+            await Promise.race([ended, timeout]);
+            abandon();
+            process.off('exit', abandon);
+            if (why && !final && !heard)
+                return null;
+            return (final ?? heard).trim();
+        },
+    };
+}
+/** Where the samples start in a WAV file this recorder wrote, or -1. */
+function dataStart(buf) {
+    const at = buf.indexOf('data', 12, 'ascii');
+    return at < 0 ? -1 : at + 8;
+}
+/**
+ * How loud the last tenth of a second was, from 0 to 1.
+ *
+ * Read off the file as it is written, so somebody speaking sees the meter move
+ * and knows they are being heard, before a single word has come back. Sixteen
+ * bit mono at 16 kHz is 3,200 bytes a tenth of a second.
+ */
+function level(file) {
+    try {
+        const size = fs.statSync(file).size;
+        const n = 3200;
+        if (size < 44 + n)
+            return 0;
+        const fd = fs.openSync(file, 'r');
+        const buf = Buffer.alloc(n);
+        fs.readSync(fd, buf, 0, n, size - n - (size - 44) % 2);
+        fs.closeSync(fd);
+        let sum = 0;
+        for (let i = 0; i + 1 < n; i += 2) {
+            const s = buf.readInt16LE(i) / 32768;
+            sum += s * s;
+        }
+        const rms = Math.sqrt(sum / (n / 2));
+        // Speech sits roughly between -50 dB (quiet room) and -10 dB (close and loud).
+        const db = 20 * Math.log10(rms || 1e-9);
+        return Math.max(0, Math.min(1, (db + 50) / 40));
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * What has been said so far, as a WAV file a transcriber can read.
+ *
+ * The recorder writes the header's lengths only when it stops, so a copy taken
+ * mid recording claims no audio at all. The copy gets the lengths of what is
+ * actually there. Returns null until there is at least half a second to send.
+ */
+function soFar(file) {
+    try {
+        const buf = fs.readFileSync(file);
+        const start = dataStart(buf);
+        if (start < 0 || buf.length - start < 16000)
+            return null;
+        const usable = buf.length - ((buf.length - start) % 2);
+        const copy = Buffer.from(buf.subarray(0, usable));
+        copy.writeUInt32LE(usable - 8, 4);
+        copy.writeUInt32LE(usable - start, start - 4);
+        const out = path.join(path.dirname(file), 'so-far.wav');
+        fs.writeFileSync(out, copy);
+        return out;
+    }
+    catch {
+        return null;
+    }
+}
 /** Delete the recording and the folder holding it. Always, and immediately. */
 function discard(file) {
     try {

package/out/thin.js

@@ -94,7 +94,7 @@ async function attachStdin(piped) {
 const WORK_VALUES = ['--mode', '--model', '--max-spend', '--max-steps', '--effort', '--resume',
     '--cwd', '--allow', '--add-folder', '--timeout', '--issue', '--team', '--output', '--worktree',
     '--schema', '--config', '--max-minutes', '--queued'];
-const WORK_SWITCHES = ['--plan', '--approve-plan', '--pin', '--sandbox', '--yes', '--background',
+const WORK_SWITCHES = ['--plan', '--approve-plan', '--pin', '--no-optimize', '--sandbox', '--yes', '--background',
     '--no-map', '--no-graph', '--quiet', '--no-personal', '--cloud'];
 /**
  * The value after a flag, or undefined when the flag was not given.
@@ -584,7 +584,7 @@ async function main() {
                 plan: args.includes('--plan'),
                 approvePlan: args.includes('--approve-plan'),
                 model: flag(args, '--model'),
-                pin: args.includes('--pin'),
+                pin: args.includes('--pin') || args.includes('--no-optimize'),
                 ...(args.includes('--max-spend') ? { maxSpend: Number(spend) } : {}),
                 ...(args.includes('--max-steps') ? { maxSteps: Number(flag(args, '--max-steps')) } : {}),
                 ...(args.includes('--max-minutes') ? { maxMinutes: Number(flag(args, '--max-minutes')) } : {}),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@illuminis/comprism",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "CompletionPrism Companion. Records what finishing a piece of work actually costs - every attempt, and the human time spent noticing and repairing the ones that failed.",
   "license": "UNLICENSED",
   "private": false,
@@ -12,6 +12,7 @@
   "files": [
     "out/**/*.js",
     "out/**/*.d.ts",
+    "out/native/dictate",
     "!out/tests/**",
     "!out/internal/**",
     "scripts/read_python.py",
@@ -22,7 +23,7 @@
     "node": ">=22"
   },
   "scripts": {
-    "build": "tsc -p ./",
+    "build": "tsc -p ./ && node scripts/build-native.mjs",
     "dev": "tsc -w -p ./",
     "test": "npm run build && node --test out/**/*.test.js",
     "gate": "npm run build && npm test && npm run shipcheck",