pi-friday 0.1.0

package/README.md

@@ -0,0 +1,137 @@
+# Friday
+
+A [pi](https://github.com/nichochar/pi) package that adds a voice-enabled communications side panel. All conversation routes to a dedicated tmux pane with typewriter effect, text-to-speech, and hands-free voice input via wake word detection.
+
+## Installation
+
+```bash
+pi install git:github.com/dantetekanem/friday
+```
+
+Or for project-local install:
+
+```bash
+pi install -l git:github.com/dantetekanem/friday
+```
+
+To try without installing:
+
+```bash
+pi -e git:github.com/dantetekanem/friday
+```
+
+## Requirements
+
+**Required** (the extension will not load without these):
+
+- **tmux** — pi already requires this
+- **perl** — pre-installed on macOS
+
+**Optional — Voice output** (TTS):
+
+- **piper-tts** — `pip3 install piper-tts`
+- **sox** — `brew install sox` (provides the `play` command)
+- A Piper voice model in `~/.local/share/piper-voices/` (see [Voices](#voices) below)
+
+Without piper-tts and sox, voice output is disabled. The panel still works for text.
+
+**Optional — Voice input** (wake word + transcription):
+
+- **openwakeword** — `pip3 install openwakeword`
+- **faster-whisper** — `pip3 install faster-whisper`
+- **pyaudio** — `pip3 install pyaudio` (requires `brew install portaudio`)
+- **sounddevice** + **numpy** — `pip3 install sounddevice numpy`
+
+Without these, the wake word listener (`/friday listen`, `Alt+L`) is unavailable.
+
+## Shortcuts
+
+| Shortcut | Action |
+|----------|--------|
+| `Alt+M` | Toggle voice on/off |
+| `Alt+L` | Toggle wake word listener on/off |
+
+## Commands
+
+| Command | Action |
+|---------|--------|
+| `/friday` | Toggle the extension on/off |
+| `/friday voice` | Toggle voice output |
+| `/friday listen` | Toggle wake word listener |
+| `/friday settings` | Show current configuration |
+
+The status bar shows active modes: `FRIDAY`, `VOICE`, `DAEMON ON`.
+
+## Wake Word
+
+Say the configured wake word (default: "hey friday") to activate hands-free voice input. After detection, Friday records your speech, transcribes it locally with faster-whisper, and sends it as a message to pi.
+
+Friday looks for custom wake word models in `~/.pi/agent/friday/`. To set up the default "hey friday" wake word:
+
+1. Visit [openwakeword.com/library](https://openwakeword.com/library) (free, requires sign-in)
+2. Search for **"hey friday"**
+3. Download the `.onnx` file to `~/.pi/agent/friday/`
+4. Set `wakeWord.model` in `settings.json` to the filename without `.onnx`
+
+You can use any custom wake word — just download its `.onnx` model to the same directory.
+
+Built-in models (no download needed): `alexa`, `hey_mycroft`, `hey_jarvis`, `hey_rhasspy`, `timer`, `weather`.
+
+## Voices
+
+Friday uses [Piper](https://github.com/rhasspy/piper) for text-to-speech. The default voice is `en_GB-jenny_dioco-medium` (British female).
+
+**Install the default voice:**
+
+```bash
+mkdir -p ~/.local/share/piper-voices
+cd ~/.local/share/piper-voices
+curl -sL -o en_GB-jenny_dioco-medium.onnx \
+  "https://huggingface.co/rhasspy/piper-voices/resolve/v1.0.0/en/en_GB/jenny_dioco/medium/en_GB-jenny_dioco-medium.onnx"
+curl -sL -o en_GB-jenny_dioco-medium.onnx.json \
+  "https://huggingface.co/rhasspy/piper-voices/resolve/v1.0.0/en/en_GB/jenny_dioco/medium/en_GB-jenny_dioco-medium.onnx.json"
+```
+
+**Use a different voice:**
+
+Browse voices at [rhasspy/piper/voices](https://huggingface.co/rhasspy/piper-voices/tree/v1.0.0). Download the `.onnx` and `.onnx.json` files to `~/.local/share/piper-voices/`, then set `voice.model` in `settings.json` to the model name (without `.onnx`).
+
+## Settings
+
+Edit `settings.json` in this directory:
+
+```json
+{
+  "name": "Friday",
+  "voice": {
+    "enabled": false,
+    "model": "en_GB-jenny_dioco-medium",
+    "speed": 0.9
+  },
+  "wakeWord": {
+    "enabled": false,
+    "model": "hey_friday",
+    "threshold": 0.3,
+    "whisperModel": "tiny.en"
+  },
+  "typewriter": {
+    "enabled": true
+  },
+  "panelWidth": 30
+}
+```
+
+| Setting | Description |
+|---------|-------------|
+| `name` | Display name in status bar |
+| `voice.model` | Piper voice model name (filename in `~/.local/share/piper-voices/` without `.onnx`) |
+| `voice.speed` | Speech speed multiplier (0.9 = slightly slower) |
+| `wakeWord.model` | openwakeword model name or custom `.onnx` filename without extension |
+| `wakeWord.threshold` | Detection confidence (0.0-1.0, lower = more sensitive) |
+| `wakeWord.whisperModel` | faster-whisper model size: `tiny.en`, `base.en`, `small.en`, `medium.en` |
+| `typewriter.enabled` | Typewriter text effect in panel |
+| `panelWidth` | Panel width as percentage of terminal |
+
+## License
+
+MIT

package/acks.ts

@@ -0,0 +1,166 @@
+/**
+ * Friday Extension - Acknowledgment System Module
+ * Acknowledgment phrases, classification, scheduling, and delivery
+ */
+
+import type { ChildProcess } from "node:child_process";
+import type { FridaySettings } from "./settings.js";
+
+export const PANEL_PHRASES = [
+	`Full details in the panel.`,
+	`More in the panel if you need it.`,
+	`Rest is on screen.`,
+	`Details on your screen.`,
+];
+
+export type AckCategory = "investigate" | "build" | "research" | "fix" | "general" | "question";
+
+export const ACK_PHRASES: Record<AckCategory, string[]> = {
+	investigate: [
+		"Looking into it.", "Let me check.", "Starting the investigation.",
+		"Pulling up the details now.", "Let me trace through that.",
+		"On it. Give me a moment.", "Checking that now.",
+	],
+	build: [
+		"On it.", "Starting now.", "I'll get that set up.",
+		"Building it out.", "Consider it started.",
+		"Spinning that up now.", "Alright, putting it together.",
+	],
+	research: [
+		"Let me look that up.", "Searching now.", "I'll find out.",
+		"Running a search.", "Let me dig into that.", "Pulling up what I can find.",
+	],
+	fix: [
+		"I see the issue. Working on it.", "Let me patch that up.",
+		"On it. Should have a fix shortly.", "Addressing that now.",
+		"I'll sort that out.", "Fixing it.",
+	],
+	general: [
+		"Copy that.", "Understood.", "Right away.", "Working on it.",
+		"One moment.", "Got it.", "Acknowledged.", "Processing.",
+	],
+	question: [
+		"One sec.", "Let me check.", "I'll look into that.",
+		"Let me see.", "Hmm, let me think.", "Good question. Let me check.",
+		"Let me find out.", "Checking.",
+	],
+};
+
+export const ACK_PATTERNS: { pattern: RegExp; category: AckCategory }[] = [
+	{ pattern: /\b(investigat|diagnos|debug|check|look into|what.s wrong|why is|trace)\b/i, category: "investigate" },
+	{ pattern: /\b(fix|repair|patch|resolve|broken|bug|error|fail|crash)\b/i, category: "fix" },
+	{ pattern: /\b(search|find|research|look up|compare|what are|which|best|recommend)\b/i, category: "research" },
+	{ pattern: /\b(build|create|add|implement|make|set up|write|generate|scaffold|deploy)\b/i, category: "build" },
+];
+
+export function hasUnquotedQuestionMark(text: string): boolean {
+	// Strip quoted/backticked content, then check for ?
+	const stripped = text
+		.replace(/`[^`]*`/g, "")
+		.replace(/"[^"]*"/g, "")
+		.replace(/'[^']*'/g, "");
+	return stripped.includes("?");
+}
+
+export function classifyPrompt(text: string): AckCategory {
+	if (hasUnquotedQuestionMark(text)) return "question";
+	for (const { pattern, category } of ACK_PATTERNS) {
+		if (pattern.test(text)) return category;
+	}
+	return "general";
+}
+
+export function pickAck(
+	category: AckCategory,
+	lastAckCategory: { value: AckCategory | null },
+	lastAckIndex: { value: number },
+): string {
+	const phrases = ACK_PHRASES[category];
+	let idx: number;
+	do {
+		idx = Math.floor(Math.random() * phrases.length);
+	} while (idx === lastAckIndex.value && category === lastAckCategory.value && phrases.length > 1);
+	lastAckCategory.value = category;
+	lastAckIndex.value = idx;
+	return phrases[idx]!;
+}
+
+export function pickPanelPhrase(): string {
+	return PANEL_PHRASES[Math.floor(Math.random() * PANEL_PHRASES.length)]!;
+}
+
+export function cancelAck(ackTimer: { value: ReturnType<typeof setTimeout> | null }) {
+	try {
+		if (ackTimer.value) { 
+			clearTimeout(ackTimer.value); 
+			ackTimer.value = null; 
+		}
+	} catch {}
+}
+
+export function scheduleAck(
+	prompt: string,
+	ackTimer: { value: ReturnType<typeof setTimeout> | null },
+	lastMessageWasQuestion: { value: boolean },
+	lastAgentEndTime: number,
+	interactionCount: { value: number },
+	lastAckCategory: { value: AckCategory | null },
+	lastAckIndex: { value: number },
+	showAndSpeak: (text: string) => void,
+	logError: (context: string, err: unknown) => void,
+) {
+	try {
+		cancelAck(ackTimer);
+		const ackCancelled = { value: false };
+
+		if (lastMessageWasQuestion.value) {
+			lastMessageWasQuestion.value = false;
+			return;
+		}
+
+		const now = Date.now();
+		const MOMENTUM_WINDOW_MS = 30000;
+		const inMomentum = (now - lastAgentEndTime) < MOMENTUM_WINDOW_MS;
+
+		if (inMomentum) {
+			interactionCount.value++;
+		} else {
+			interactionCount.value = 0;
+		}
+
+		if (interactionCount.value >= 3) return;
+		if (interactionCount.value > 0 && Math.random() > 1 / (interactionCount.value + 1)) return;
+
+		const category = classifyPrompt(prompt);
+		const ack = pickAck(category, lastAckCategory, lastAckIndex);
+
+		const ACK_DELAY_MS = 2000;
+		// CRITICAL FIX: Add .unref() to ack timer
+		ackTimer.value = setTimeout(() => {
+			try {
+				if (ackCancelled.value) return;
+				showAndSpeak(ack);
+			} catch (e) { logError("ackTimer.callback", e); }
+		}, ACK_DELAY_MS).unref();
+	} catch (e) { logError("scheduleAck", e); }
+}
+
+export function showAndSpeak(
+	text: string,
+	voiceEnabled: boolean,
+	ensurePanelOpen: () => Promise<boolean>,
+	writeMessage: (text: string) => void,
+	enqueueVoiceWithMessage: (text: string, speed?: number) => void,
+	settings: FridaySettings,
+	logError: (context: string, err: unknown) => void,
+) {
+	try {
+		if (voiceEnabled) {
+			enqueueVoiceWithMessage(text, settings.voice.speed);
+		} else {
+			ensurePanelOpen().then((ok) => {
+				try { if (ok) writeMessage(text); } catch (e) { logError("showAndSpeak.panel", e); }
+			}).catch((e) => logError("showAndSpeak.ensurePanel", e));
+		}
+	} catch (e) { logError("showAndSpeak", e); }
+}

package/daemon.ts

@@ -0,0 +1,161 @@
+/**
+ * Friday Extension - Wake Word Daemon Module
+ * Wake word daemon management, file watching, and voice command handling
+ */
+
+import { spawn, type ChildProcess } from "node:child_process";
+import { promisify } from "node:util";
+import { exec as execCb } from "node:child_process";
+const execAsync = promisify(execCb);
+import { writeFileSync, readFileSync, existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { FridaySettings } from "./settings.js";
+import type { FSWatcher } from "node:fs";
+
+export async function killOrphanDaemons(log: (msg: string) => void) {
+	try {
+		const { stdout } = await execAsync(
+			"ps aux | grep wake_daemon.py | grep -v grep",
+			{ encoding: "utf8", timeout: 5000 },
+		);
+		const result = stdout.trim();
+		if (!result) return;
+		for (const line of result.split("\n")) {
+			const parts = line.trim().split(/\s+/);
+			const pid = parseInt(parts[1]!, 10);
+			if (!pid || isNaN(pid)) continue;
+			try { 
+				process.kill(pid, "SIGTERM"); 
+				log(`Killed orphan wake daemon (PID ${pid})`); 
+			} catch {}
+		}
+	} catch { /* no orphans found (grep exits 1) */ }
+}
+
+export function startWakeDaemon(
+	settings: FridaySettings,
+	commsDir: string,
+	commandFile: string,
+	log: (msg: string) => void,
+	logError: (context: string, err: unknown) => void,
+): ChildProcess | null {
+	try {
+		mkdirSync(commsDir, { recursive: true });
+
+		const DAEMON_SCRIPT = join(
+			import.meta.dirname,
+			"wake_daemon.py",
+		);
+
+		const dataDir = join(process.env.HOME ?? "~", ".pi/agent/friday");
+
+		const args = [
+			DAEMON_SCRIPT,
+			commandFile,
+			"--wake-word", settings.wakeWord.model,
+			"--threshold", String(settings.wakeWord.threshold),
+			"--whisper-model", settings.wakeWord.whisperModel,
+			"--data-dir", dataDir,
+		];
+
+		const wakeDaemon = spawn("python3", args, {
+			stdio: ["ignore", "pipe", "pipe"],
+			detached: false,
+		});
+
+		// Unref so the daemon doesn't keep the event loop alive on shutdown
+		wakeDaemon.unref();
+
+		wakeDaemon.stderr?.on("data", (data: Buffer) => {
+			try { const line = data.toString().trim(); if (line) log(line); } catch {}
+		});
+
+		wakeDaemon.on("exit", (code) => {
+			try {
+				log(`Wake daemon exited (code: ${code})`);
+			} catch (e) { logError("wakeDaemon.exit", e); }
+		});
+
+		log("Wake daemon started");
+		return wakeDaemon;
+	} catch (e) { 
+		logError("startWakeDaemon", e); 
+		return null;
+	}
+}
+
+export function stopWakeDaemon(wakeDaemon: ChildProcess | null, logError: (context: string, err: unknown) => void) {
+	try {
+		if (wakeDaemon) {
+			// Destroy stdio streams so they don't hold the event loop
+			try { wakeDaemon.stdout?.destroy(); } catch {}
+			try { wakeDaemon.stderr?.destroy(); } catch {}
+			// SIGKILL for instant death on shutdown
+			wakeDaemon.kill("SIGKILL");
+		}
+	} catch (e) { logError("stopWakeDaemon", e); }
+}
+
+export function startWakeWatcher(
+	commandFile: string,
+	lastCommandTimestamp: { value: number },
+	killCurrentVoice: () => void,
+	handleWakeCommand: (text: string) => void,
+	logError: (context: string, err: unknown) => void,
+): any {
+	try {
+		// CRITICAL FIX: Add .unref() to background interval timer
+		const interval = setInterval(() => {
+			try {
+				if (!existsSync(commandFile)) return;
+				const raw = readFileSync(commandFile, "utf8").trim();
+				if (!raw) return;
+				const cmd = JSON.parse(raw);
+				if (!cmd.timestamp || cmd.timestamp <= lastCommandTimestamp.value) return;
+				lastCommandTimestamp.value = cmd.timestamp;
+
+				if (cmd.type === "wake") {
+					killCurrentVoice();
+				} else if (cmd.type === "command" && cmd.text) {
+					handleWakeCommand(cmd.text);
+				}
+			} catch { /* ignore parse errors on partial writes */ }
+		}, 100).unref();
+		
+		return { close: () => clearInterval(interval) } as any;
+	} catch (e) { 
+		logError("startWakeWatcher", e);
+		return null; 
+	}
+}
+
+export function stopWakeWatcher(wakeWatcher: any, logError: (context: string, err: unknown) => void) {
+	try {
+		if (wakeWatcher) {
+			wakeWatcher.close?.();
+		}
+	} catch (e) { logError("stopWakeWatcher", e); }
+}
+
+export function handleWakeCommand(
+	text: string, 
+	pi: ExtensionAPI,
+	log: (msg: string) => void,
+	logError: (context: string, err: unknown) => void,
+) {
+	try {
+		log(`Voice command: ${text}`);
+		pi.sendUserMessage(text, { deliverAs: "followUp" });
+	} catch (e) {
+		// This is the most critical catch — sendUserMessage throws when
+		// the agent is already processing and deliverAs isn't accepted.
+		// We MUST swallow this or it kills the host agent.
+		logError("handleWakeCommand", e);
+	}
+}
+
+export function isDaemonAlive(wakeDaemon: ChildProcess | null): boolean {
+	if (!wakeDaemon || !wakeDaemon.pid) return false;
+	try { process.kill(wakeDaemon.pid, 0); return true; } catch { return false; }
+}