@clearlysh/beehaven 0.8.16

package/dist/commands/voice.js

@@ -0,0 +1,166 @@
+/**
+ * `beehaven voice` — push-to-talk REPL orchestrating existing hives.
+ *
+ * This command does NO direct audio handling. Every piece of the loop
+ * routes through beehaven hives:
+ *
+ *   1. user hits ENTER → call `recorder:record { source: 'mic' }`
+ *   2. user hits ENTER again → call `recorder:stop`
+ *   3. get the transcribed text from the recording result
+ *   4. forward the text to the connected DO via `ask`
+ *   5. speak the response via `avatar:speak { text }`
+ *
+ * That means voice mode works wherever the recorder + avatar hives
+ * are installed — no Node-level microphone or TTS libraries ship with
+ * the CLI, and the voice experience stays tied to whatever audio
+ * platform the hives themselves handle (today: macOS BlackHole +
+ * Kokoro TTS via the Clearly Dev Mac app bundle).
+ *
+ * ## Exit
+ * Ctrl+C or type `:quit` at the prompt.
+ */
+import { isDaemonRunning } from '../daemon-client.js';
+import { appRpcOnce } from '../ipc-client.js';
+import { cmdAsk } from './workspace.js';
+import { color } from '../spinner.js';
+import { createInterface } from 'readline';
+async function callApp(building, action, input) {
+    return appRpcOnce(action, input ?? {}, { building, instanceId: 'live', timeout: 30_000 });
+}
+export async function cmdVoice(values) {
+    if (!(await isDaemonRunning())) {
+        console.error(color.red('✗') + ' Daemon not running. Start it:  beehaven start --headless\n    (or open the Hive Mac app, which runs one for you.)');
+        process.exit(1);
+    }
+    // Probe for recorder + avatar hives. Graceful failure if either's missing.
+    const recorderOk = await probeHive('recorder', 'list-sources');
+    const avatarOk = await probeHive('avatar', 'emote');
+    if (!recorderOk) {
+        console.error(color.red('✗') + ' recorder hive not installed. Install via `beehaven install recorder`.');
+        process.exit(1);
+    }
+    if (!avatarOk) {
+        console.error(color.yellow('!') + ' avatar hive not installed — responses will be text-only.');
+        console.error('  Install via `beehaven install avatar` for spoken replies.');
+    }
+    console.log('');
+    console.log(`  ${color.bold('Beehaven Voice')} — push-to-talk REPL`);
+    console.log(`  ${color.dim('Press ENTER to start recording, ENTER again to stop. Type :quit to exit.')}`);
+    console.log('');
+    const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+    let recording = false;
+    const ask = async (transcript) => {
+        try {
+            // Delegate to existing cmdAsk so auto-routing to the connected
+            // building stays in one place. Capture its stdout by swapping
+            // console.log — cheesy but avoids duplicating the RPC plumbing.
+            let captured = '';
+            const origLog = console.log.bind(console);
+            console.log = (...args) => {
+                captured += args.join(' ') + '\n';
+            };
+            try {
+                await cmdAsk(transcript, values);
+            }
+            finally {
+                console.log = origLog;
+            }
+            return captured.trim() || null;
+        }
+        catch (err) {
+            console.error(color.red('✗') + ` ask failed: ${err?.message ?? err}`);
+            return null;
+        }
+    };
+    const record = async () => {
+        try {
+            await callApp('recorder', 'record', { source: 'mic' });
+            return null;
+        }
+        catch (err) {
+            console.error(color.red('✗') + ` recorder:record failed: ${err?.message ?? err}`);
+            return null;
+        }
+    };
+    const stop = async () => {
+        try {
+            const result = (await callApp('recorder', 'stop', {}));
+            const transcript = result?.transcript ?? result?.text ?? '';
+            return typeof transcript === 'string' && transcript.length > 0 ? transcript : null;
+        }
+        catch (err) {
+            console.error(color.red('✗') + ` recorder:stop failed: ${err?.message ?? err}`);
+            return null;
+        }
+    };
+    const speak = async (text) => {
+        if (!avatarOk) {
+            console.log(text);
+            return;
+        }
+        try {
+            await callApp('avatar', 'speak', { text });
+        }
+        catch (err) {
+            console.error(color.yellow('!') + ` avatar:speak failed (printing text instead): ${err?.message ?? err}`);
+            console.log(text);
+        }
+    };
+    process.on('SIGINT', () => {
+        rl.close();
+        console.log('\n  Goodbye.');
+        process.exit(0);
+    });
+    rl.on('line', async (line) => {
+        const trimmed = line.trim();
+        if (trimmed === ':quit' || trimmed === ':q') {
+            rl.close();
+            console.log('  Goodbye.');
+            process.exit(0);
+        }
+        if (!recording) {
+            recording = true;
+            console.log(color.dim('  ● recording… (press ENTER again to stop)'));
+            await record();
+        }
+        else {
+            recording = false;
+            const transcript = await stop();
+            if (!transcript) {
+                console.log(color.dim('  (no speech detected)'));
+                rl.prompt();
+                return;
+            }
+            console.log(color.bold('  you: ') + transcript);
+            const response = await ask(transcript);
+            if (response) {
+                console.log(color.bold('  ai:  ') + response);
+                await speak(response);
+            }
+        }
+        rl.prompt();
+    });
+    rl.setPrompt('  ▸ ');
+    rl.prompt();
+}
+// ── Helper — probe whether a hive is installed ──────────────────────────
+async function probeHive(appName, probeAction) {
+    try {
+        // Try a read-only action that every hive handles. If the daemon
+        // responds with a known-app error, the hive isn't installed.
+        await callApp(appName, probeAction, {});
+        return true;
+    }
+    catch (err) {
+        const msg = String(err?.message ?? err ?? '').toLowerCase();
+        // If the error is "action not found," the hive IS installed — just
+        // didn't have this specific probe action. Treat as success.
+        if (msg.includes('unknown action') || msg.includes('action not found'))
+            return true;
+        if (msg.includes('not installed') || msg.includes('no such app') || msg.includes('not found'))
+            return false;
+        // Ambiguous — assume installed and let the real call fail loudly
+        // if it's actually broken.
+        return true;
+    }
+}

package/dist/commands/watch-git.js

@@ -0,0 +1,401 @@
+/**
+ * `beehaven watch git` — capture a local git diff and land it on the Clearly
+ * spatial canvas as a DiffNode, so an agent's (or your own) code changes show up
+ * on the composition the user is working in.
+ *
+ * The diff is sent to the connected DO via the LOCKED canvas contract:
+ *
+ *   action:  canvas-act
+ *   input:   { compositionId, action:'canvas.add-diff', args:{ diff, title?, commit? } }
+ *
+ * Routing reuses the exact `call` path: resolveBuilding(action, input, --building)
+ * then rpcOnce(resolved.action, resolved.input, timeout). The cli.ts `watch`
+ * dispatch derives --building from the connected target (default home) before
+ * calling us, so a bare `beehaven connect home && beehaven watch git <id>` lands
+ * on home — the DO that holds compositions.
+ *
+ * Modes:
+ *   beehaven watch git <compId>                  # working-tree diff (git diff HEAD), one-shot
+ *   beehaven watch git --staged                  # staged diff (git diff --staged)
+ *   beehaven watch git --commit <sha>            # that commit's diff + subject as title
+ *   beehaven watch git --range <a>..<b>          # diff between two refs
+ *   beehaven watch git --watch                   # poll HEAD; push each NEW commit's diff
+ *
+ * The composition id comes from --composition / --comp / -c, or positionals[0].
+ * With none given we default to the most-recently-updated composition (via
+ * canvas-list-compositions); pass --composition <id> to be explicit.
+ *
+ * The action it calls (canvas.add-diff) ships with the worker in a parallel
+ * piece of this feature — until that deploys the call returns "Unknown action",
+ * which is expected. The wiring is correct against the contract.
+ */
+import { execFileSync } from 'node:child_process';
+import { resolveBuilding, getTimeout } from './workspace.js';
+import { rpcOnce } from '../ipc-client.js';
+// ── git helpers ────────────────────────────────────────────────────────────
+/**
+ * Run a git command in the CWD, returning trimmed stdout. Throws GitError on
+ * failure (non-git dir, bad ref, git not installed) so callers can fail with a
+ * friendly message instead of a stack trace.
+ */
+function git(args) {
+    try {
+        return execFileSync('git', args, {
+            cwd: process.cwd(),
+            encoding: 'utf8',
+            // A whole-repo diff can be large; lift the default 1MB buffer. It's just
+            // a string in the RPC, so a big diff is fine — we only need not to choke
+            // capturing it.
+            maxBuffer: 256 * 1024 * 1024,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        }).toString();
+    }
+    catch (err) {
+        const stderr = (err?.stderr ? err.stderr.toString() : '') || err?.message || 'git failed';
+        throw new GitError(stderr.trim());
+    }
+}
+class GitError extends Error {
+}
+/** Best-effort current branch name (empty string if detached / unavailable). */
+function currentBranch() {
+    try {
+        const b = git(['rev-parse', '--abbrev-ref', 'HEAD']).trim();
+        return b === 'HEAD' ? '' : b;
+    }
+    catch {
+        return '';
+    }
+}
+/** Confirm we're inside a git work tree, or throw a clear GitError. */
+function assertGitRepo() {
+    let inside = '';
+    try {
+        inside = git(['rev-parse', '--is-inside-work-tree']).trim();
+    }
+    catch (err) {
+        throw new GitError(`not a git repository (or git is unavailable): ${err?.message ?? ''}`.trim());
+    }
+    if (inside !== 'true')
+        throw new GitError('not inside a git work tree');
+}
+/** Short SHA for a ref (falls back to the raw ref string on failure). */
+function shortSha(ref) {
+    try {
+        return git(['rev-parse', '--short', ref]).trim();
+    }
+    catch {
+        return ref;
+    }
+}
+/** Subject line of a commit (empty string on failure). */
+function commitSubject(ref) {
+    try {
+        return git(['log', '-1', '--format=%s', ref]).trim();
+    }
+    catch {
+        return '';
+    }
+}
+/** Count of files touched by a diff string (cheap heuristic on the patch). */
+function fileCount(diff) {
+    const m = diff.match(/^diff --git /gm);
+    return m ? m.length : 0;
+}
+// ── help ───────────────────────────────────────────────────────────────────
+function printWatchGitHelp() {
+    console.log('');
+    console.log('  beehaven watch git — push a local git diff onto the Clearly canvas');
+    console.log('  ─────────────────────────────────────────────────────────────────');
+    console.log('');
+    console.log('  Usage:');
+    console.log('    beehaven watch git [<compositionId>] [mode-flag]');
+    console.log('');
+    console.log('  Composition target (required — one of):');
+    console.log('    <compositionId>                  positional');
+    console.log('    --composition <id> | --comp <id> | -c <id>');
+    console.log('    (none)                           defaults to your most-recently-updated');
+    console.log('                                     composition; ambiguous → pass --composition');
+    console.log('');
+    console.log('  Modes (default = working-tree diff, one-shot):');
+    console.log('    (default)                        git diff HEAD  (unstaged + working changes)');
+    console.log('    --staged                         git diff --staged');
+    console.log("    --commit <sha>                   that commit's diff, subject as the title");
+    console.log('    --range <a>..<b>                 git diff <a> <b>');
+    console.log("    --watch                          poll HEAD ~2s; push each NEW commit's diff");
+    console.log('                                     (runs until Ctrl-C)');
+    console.log('');
+    console.log('  Examples:');
+    console.log('    beehaven connect home');
+    console.log('    beehaven watch git                       # latest comp, current working changes');
+    console.log('    beehaven watch git comp_abc123 --staged');
+    console.log('    beehaven watch git --commit HEAD~1 -c comp_abc123');
+    console.log('    beehaven watch git --range main..feature');
+    console.log('    beehaven watch git --watch               # live: each new commit → a diff card');
+    console.log('');
+}
+// ── composition resolution ──────────────────────────────────────────────────
+/**
+ * Resolve which composition the diff lands on. Precedence:
+ *   1. explicit flag (--composition / --comp / -c) or positionals[0]
+ *   2. the most-recently-updated composition (canvas-list-compositions returns
+ *      rows ordered by updated_at DESC, so compositions[0] is newest)
+ * Throws on an ambiguous/empty default so we never guess wrong.
+ */
+async function resolveCompositionId(positionals, values) {
+    const explicit = typeof values.composition === 'string' && values.composition.trim()
+        ? values.composition.trim()
+        : typeof values.comp === 'string' && values.comp.trim()
+            ? values.comp.trim()
+            : typeof values.c === 'string' && values.c.trim()
+                ? values.c.trim()
+                : positionals[0] && positionals[0].trim()
+                    ? positionals[0].trim()
+                    : '';
+    if (explicit)
+        return explicit;
+    // No id given — try the most-recent composition on the connected DO.
+    const resolved = resolveBuilding('canvas-list-compositions', { limit: 10 }, values.building);
+    let raw;
+    try {
+        raw = await rpcOnce(resolved.action, resolved.input, getTimeout(values));
+    }
+    catch (err) {
+        throw new Error(`Could not list compositions to pick a default (${err?.message ?? 'rpc failed'}).\n` +
+            `  Pass one explicitly:  beehaven watch git --composition <id>`);
+    }
+    // Unwrap the admin:*-rpc proxy envelope when --building routed the call.
+    const result = raw?.type === 'ack' && raw?.result !== undefined
+        ? raw.result
+        : raw?.result !== undefined && values.building
+            ? raw.result
+            : raw;
+    if (raw?.type === 'error' || result?.error) {
+        const msg = raw?.message ?? result?.error ?? 'unknown error';
+        throw new Error(`Could not list compositions to pick a default (${msg}).\n` +
+            `  Pass one explicitly:  beehaven watch git --composition <id>`);
+    }
+    const comps = Array.isArray(result?.compositions)
+        ? result.compositions
+        : [];
+    if (comps.length === 0) {
+        throw new Error('No compositions found on this workspace to default to.\n' +
+            '  Create one in the app, then pass:  beehaven watch git --composition <id>');
+    }
+    const picked = comps[0];
+    if (!picked?.id) {
+        throw new Error('Could not determine a default composition — pass --composition <id>.');
+    }
+    console.error(`\x1b[2m→ no composition given; defaulting to most-recent: ${picked.title ?? picked.id} (${picked.id})\x1b[0m`);
+    return picked.id;
+}
+/** Capture the diff + title for the chosen one-shot mode. */
+function captureOneShot(values) {
+    // --commit <sha>: that single commit's patch, its subject as the title.
+    const commit = typeof values.commit === 'string' && values.commit.trim() ? values.commit.trim() : '';
+    if (commit) {
+        const sha = shortSha(commit);
+        const subject = commitSubject(commit);
+        // `git show <sha>` includes the patch; restrict to the patch with diff form
+        // so the node renders a clean diff (not the commit header twice).
+        const diff = git(['diff', `${commit}^`, commit]);
+        return { diff, title: subject || `Commit ${sha}`, commit: sha };
+    }
+    // --range <a>..<b> (also tolerates "a b" / "a..b").
+    const range = typeof values.range === 'string' && values.range.trim() ? values.range.trim() : '';
+    if (range) {
+        const parts = range.includes('..')
+            ? range.split('..').filter(Boolean)
+            : range.split(/\s+/).filter(Boolean);
+        if (parts.length !== 2) {
+            throw new GitError(`--range expects <a>..<b> (got "${range}")`);
+        }
+        const [a, b] = parts;
+        const diff = git(['diff', a, b]);
+        return { diff, title: `Diff ${shortSha(a)}..${shortSha(b)}` };
+    }
+    // --staged: the index against HEAD.
+    if (values.staged === true) {
+        const diff = git(['diff', '--staged']);
+        const stat = git(['diff', '--staged', '--shortstat']).trim();
+        const branch = currentBranch();
+        return {
+            diff,
+            title: `Staged changes${branch ? ` — ${branch}` : ''}${stat ? ` (${stat})` : ''}`,
+        };
+    }
+    // Default: working-tree changes (unstaged + tracked modifications) vs HEAD.
+    const diff = git(['diff', 'HEAD']);
+    const stat = git(['diff', 'HEAD', '--shortstat']).trim();
+    const branch = currentBranch();
+    return {
+        diff,
+        title: `Working changes${branch ? ` — ${branch}` : ''}${stat ? ` (${stat})` : ''}`,
+    };
+}
+// ── push ────────────────────────────────────────────────────────────────────
+/**
+ * Send one diff to the canvas via canvas-act → canvas.add-diff, reusing the
+ * exact `call` path (resolveBuilding + rpcOnce). Returns the unwrapped value or
+ * throws on a proxied/transport error. Skips empty diffs (no empty card).
+ */
+async function pushDiff(compositionId, cap, values) {
+    if (!cap.diff || !cap.diff.trim()) {
+        return { skipped: true };
+    }
+    const args = { diff: cap.diff };
+    if (cap.title)
+        args.title = cap.title;
+    if (cap.commit)
+        args.commit = cap.commit;
+    const input = { compositionId, action: 'canvas.add-diff', args };
+    const resolved = resolveBuilding('canvas-act', input, values.building);
+    if (!values.json) {
+        const target = values.building ? values.building : 'home';
+        console.error(`\x1b[2m→ ${target}  canvas-act canvas.add-diff (${fileCount(cap.diff)} files, ${cap.diff.length}B)\x1b[0m`);
+    }
+    const raw = await rpcOnce(resolved.action, resolved.input, getTimeout(values));
+    if (raw?.type === 'error') {
+        throw new Error(raw.message ?? 'canvas-act failed');
+    }
+    const value = raw?.type === 'ack' && raw?.result !== undefined
+        ? raw.result
+        : raw?.result !== undefined && values.building
+            ? raw.result
+            : raw;
+    return { skipped: false, value };
+}
+// ── entrypoint ──────────────────────────────────────────────────────────────
+export async function cmdWatchGit(positionals, values) {
+    // Subcommand help — reachable as `watch git --help`, `-h`, or `watch git help`.
+    if (values.help === true || positionals[0] === 'help') {
+        printWatchGitHelp();
+        return;
+    }
+    // Validate we're in a git repo up front — every mode needs it.
+    try {
+        assertGitRepo();
+    }
+    catch (err) {
+        console.error(`  ${err?.message ?? 'not a git repository'}`);
+        console.error('  Run beehaven watch git from inside a git repository.');
+        process.exit(1);
+    }
+    let compositionId;
+    try {
+        compositionId = await resolveCompositionId(positionals, values);
+    }
+    catch (err) {
+        console.error(`  ${err?.message ?? 'could not resolve a composition'}`);
+        process.exit(1);
+        return; // unreachable, keeps TS happy about compositionId being assigned
+    }
+    // ── --watch: poll HEAD, push each NEW commit's diff until Ctrl-C ──────────
+    if (values.watch === true) {
+        let prev = '';
+        try {
+            prev = git(['rev-parse', 'HEAD']).trim();
+        }
+        catch {
+            // Empty repo (no commits yet) — start from nothing; the first commit fires a push.
+            prev = '';
+        }
+        console.error(`  Watching HEAD for new commits → composition ${compositionId} (Ctrl-C to stop)`);
+        if (prev)
+            console.error(`\x1b[2m  baseline: ${shortSha(prev)}\x1b[0m`);
+        let stopped = false;
+        const onSig = () => {
+            stopped = true;
+            console.error('\n  stopped.');
+            process.exit(0);
+        };
+        process.on('SIGINT', onSig);
+        process.on('SIGTERM', onSig);
+        // Simple ~2s poll loop. Cheap (one rev-parse) and robust — no .git/logs
+        // watching needed, and it survives rebases/amends (any HEAD move fires).
+        while (!stopped) {
+            await new Promise((r) => setTimeout(r, 2000));
+            if (stopped)
+                break;
+            let head = '';
+            try {
+                head = git(['rev-parse', 'HEAD']).trim();
+            }
+            catch {
+                continue; // transient (mid-rebase, etc.) — try again next tick
+            }
+            if (!head || head === prev)
+                continue;
+            // New commit(s). Diff the span prev..head (or just the new commit when
+            // there was no baseline). Title = the newest commit's subject.
+            const sha = shortSha(head);
+            const subject = commitSubject(head);
+            let diff = '';
+            try {
+                diff = prev ? git(['diff', prev, head]) : git(['show', head]);
+            }
+            catch (err) {
+                console.error(`  ! could not capture diff for ${sha}: ${err?.message ?? 'git failed'}`);
+                prev = head;
+                continue;
+            }
+            const cap = { diff, title: subject || `Commit ${sha}`, commit: sha };
+            try {
+                const res = await pushDiff(compositionId, cap, values);
+                if (res.skipped) {
+                    console.error(`  (no changes in ${sha} — skipped)`);
+                }
+                else {
+                    console.log(`  ✓ pushed ${fileCount(diff)} files for ${sha} "${subject || '(no subject)'}"`);
+                }
+            }
+            catch (err) {
+                console.error(`  ! push failed for ${sha}: ${err?.message ?? 'unknown error'}`);
+            }
+            prev = head;
+        }
+        return;
+    }
+    // ── one-shot ─────────────────────────────────────────────────────────────
+    let cap;
+    try {
+        cap = captureOneShot(values);
+    }
+    catch (err) {
+        console.error(`  ${err?.message ?? 'could not capture a diff'}`);
+        process.exit(1);
+        return;
+    }
+    if (!cap.diff || !cap.diff.trim()) {
+        console.log('  no changes');
+        return;
+    }
+    try {
+        const res = await pushDiff(compositionId, cap, values);
+        if (res.skipped) {
+            console.log('  no changes');
+            return;
+        }
+        if (values.json) {
+            console.log(JSON.stringify(res.value, null, 2));
+            return;
+        }
+        if (res.value && typeof res.value === 'object') {
+            console.log(JSON.stringify(res.value, null, 2));
+        }
+        else {
+            console.log(res.value);
+        }
+        console.error(`  ✓ pushed ${fileCount(cap.diff)} files — "${cap.title}" → composition ${compositionId}`);
+    }
+    catch (err) {
+        console.error(JSON.stringify({ error: err?.message ?? 'unknown error' }, null, 2));
+        const s = String(err?.message ?? '').toLowerCase();
+        if (s.includes('unknown action')) {
+            console.error('');
+            console.error("\x1b[2m  canvas.add-diff isn't on the deployed worker yet — this is expected until");
+            console.error('  the backend piece ships. The wiring is correct against the contract.\x1b[0m');
+        }
+        process.exit(1);
+    }
+}