speech-opencode 1.0.0

package/README.md

@@ -0,0 +1,112 @@
+# speech-opencode
+
+Voice input plugin for [OpenCode](https://opencode.ai) using OpenAI Whisper.
+
+Record audio from your microphone and transcribe it to text using OpenAI's Whisper API.
+
+## Installation
+
+Add the plugin to your `opencode.json`:
+
+```json
+{
+  "plugin": ["speech-opencode"]
+}
+```
+
+## Requirements
+
+### API Key
+
+Set your OpenAI API key as an environment variable:
+
+```bash
+export OPENAI_API_KEY=your-api-key
+```
+
+### Audio Recording Tools
+
+**Linux (PulseAudio/PipeWire):**
+```bash
+# Ubuntu/Debian
+sudo apt install pulseaudio-utils
+
+# Fedora
+sudo dnf install pulseaudio-utils
+
+# Arch
+sudo pacman -S pulseaudio-utils
+```
+
+**macOS:**
+```bash
+brew install sox
+```
+
+## Usage
+
+Once installed, OpenCode will have access to a `voice` tool. You can ask OpenCode to use it:
+
+- "Listen to my voice"
+- "Record what I say"
+- "Use voice input"
+- "Transcribe my speech for 10 seconds"
+
+The tool accepts an optional `duration` parameter (default: 5 seconds, max: 60 seconds).
+
+## Configuration
+
+For advanced configuration, create a local plugin file:
+
+**.opencode/plugin/voice.ts:**
+```typescript
+import { VoicePlugin } from "speech-opencode"
+
+export default VoicePlugin({
+  // Optional: specify language (auto-detects if not set)
+  language: "en",
+  
+  // Optional: default recording duration in seconds
+  defaultDuration: 5,
+  
+  // Optional: maximum recording duration in seconds
+  maxDuration: 60,
+  
+  // Optional: override API key (defaults to OPENAI_API_KEY env var)
+  apiKey: process.env.MY_OPENAI_KEY,
+})
+```
+
+## Supported Languages
+
+Whisper supports many languages including:
+- English (`en`)
+- Spanish (`es`)
+- French (`fr`)
+- German (`de`)
+- Japanese (`ja`)
+- Chinese (`zh`)
+- And many more...
+
+Leave `language` unset for automatic detection.
+
+## How It Works
+
+1. Records audio from your default microphone using system tools
+2. Sends the audio to OpenAI's Whisper API for transcription
+3. Returns the transcribed text to OpenCode
+
+## Troubleshooting
+
+### No audio detected
+- Check that your microphone is not muted
+- Verify the correct input device is selected in your system settings
+- On Linux, use `pavucontrol` to check input sources
+
+### Recording fails
+- Ensure you have the required audio tools installed
+- Check that your microphone permissions are granted
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,36 @@
+import { type Plugin } from "@opencode-ai/plugin";
+export interface VoicePluginOptions {
+    /** OpenAI API key. Defaults to OPENAI_API_KEY env var */
+    apiKey?: string;
+    /** Language code for transcription (e.g., "en", "es", "fr"). Auto-detects if not specified */
+    language?: string;
+    /** Default recording duration in seconds */
+    defaultDuration?: number;
+    /** Maximum allowed recording duration in seconds */
+    maxDuration?: number;
+}
+/**
+ * OpenCode Voice Plugin
+ *
+ * Adds a 'voice' tool that records audio from the microphone and transcribes it
+ * using OpenAI's Whisper API.
+ *
+ * @example
+ * ```ts
+ * // In opencode.json
+ * {
+ *   "plugin": ["opencode-voice"]
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With options in .opencode/plugin/voice.ts
+ * import { VoicePlugin } from "opencode-voice"
+ * export default VoicePlugin({ language: "en", defaultDuration: 10 })
+ * ```
+ */
+export declare const VoicePlugin: (options?: VoicePluginOptions) => Plugin;
+declare const _default: Plugin;
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAQ,MAAM,qBAAqB,CAAA;AA6LvD,MAAM,WAAW,kBAAkB;IACjC,yDAAyD;IACzD,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,8FAA8F;IAC9F,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,4CAA4C;IAC5C,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,oDAAoD;IACpD,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,WAAW,GACrB,UAAS,kBAAuB,KAAG,MAoEnC,CAAA;;AAGH,wBAA4B"}

package/dist/index.js

@@ -0,0 +1,224 @@
+import { tool } from "@opencode-ai/plugin";
+import OpenAI from "openai";
+import { spawn } from "child_process";
+import { unlinkSync, readFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+/**
+ * Gets the first available non-monitor, non-bluetooth audio input source
+ * Works with PulseAudio and PipeWire on Linux
+ */
+async function getDefaultInputDevice() {
+    return new Promise((resolve) => {
+        const pactl = spawn("pactl", ["list", "sources", "short"]);
+        let output = "";
+        pactl.stdout.on("data", (data) => {
+            output += data.toString();
+        });
+        pactl.on("close", () => {
+            const lines = output.trim().split("\n");
+            for (const line of lines) {
+                const parts = line.split("\t");
+                if (parts.length >= 2) {
+                    const name = parts[1];
+                    // Skip monitor sources and bluetooth (prefer hardware input)
+                    if (!name.includes(".monitor") && !name.includes("bluez")) {
+                        resolve(name);
+                        return;
+                    }
+                }
+            }
+            resolve(null);
+        });
+        pactl.on("error", () => resolve(null));
+    });
+}
+/**
+ * Records audio from the microphone
+ * - Linux: Uses parecord (PulseAudio/PipeWire) or arecord (ALSA)
+ * - macOS: Uses sox (rec command)
+ */
+async function recordAudio(durationSeconds = 5) {
+    const tempFile = join(tmpdir(), `opencode-voice-${Date.now()}.wav`);
+    const platform = process.platform;
+    if (platform === "darwin") {
+        // macOS: use sox
+        return recordWithSox(tempFile, durationSeconds);
+    }
+    else {
+        // Linux: use parecord or arecord
+        return recordWithPulseAudio(tempFile, durationSeconds);
+    }
+}
+async function recordWithSox(tempFile, durationSeconds) {
+    return new Promise((resolve, reject) => {
+        const recorder = spawn("rec", [
+            "-q",
+            "-r",
+            "16000",
+            "-c",
+            "1",
+            "-b",
+            "16",
+            tempFile,
+            "trim",
+            "0",
+            durationSeconds.toString(),
+        ]);
+        let errorOutput = "";
+        recorder.stderr.on("data", (data) => {
+            errorOutput += data.toString();
+        });
+        recorder.on("error", () => {
+            reject(new Error("sox not found. Please install it:\n" + "  - macOS: brew install sox"));
+        });
+        recorder.on("close", (code) => {
+            if (code === 0) {
+                resolve(tempFile);
+            }
+            else {
+                reject(new Error(`Recording failed: ${errorOutput}`));
+            }
+        });
+    });
+}
+async function recordWithPulseAudio(tempFile, durationSeconds) {
+    const inputDevice = await getDefaultInputDevice();
+    return new Promise((resolve, reject) => {
+        const args = [(durationSeconds + 1).toString(), "parecord"];
+        if (inputDevice) {
+            args.push(`--device=${inputDevice}`);
+        }
+        args.push("--file-format=wav", tempFile);
+        const recorder = spawn("timeout", args);
+        let errorOutput = "";
+        recorder.stderr.on("data", (data) => {
+            errorOutput += data.toString();
+        });
+        recorder.on("error", () => {
+            // Fallback to arecord
+            const arecord = spawn("arecord", [
+                "-q",
+                "-f",
+                "S16_LE",
+                "-r",
+                "16000",
+                "-c",
+                "1",
+                "-d",
+                durationSeconds.toString(),
+                tempFile,
+            ]);
+            arecord.on("error", () => {
+                reject(new Error("No audio recorder found. Please install:\n" +
+                    "  - Ubuntu/Debian: sudo apt install pulseaudio-utils\n" +
+                    "  - Fedora: sudo dnf install pulseaudio-utils\n" +
+                    "  - Arch: sudo pacman -S pulseaudio-utils"));
+            });
+            arecord.on("close", (code) => {
+                if (code === 0) {
+                    resolve(tempFile);
+                }
+                else {
+                    reject(new Error(`arecord failed with code ${code}`));
+                }
+            });
+        });
+        recorder.on("close", (code) => {
+            // timeout returns 124 when it kills the process, which is expected
+            if (code === 0 || code === 124) {
+                resolve(tempFile);
+            }
+            else {
+                reject(new Error(`Recording failed (code ${code}): ${errorOutput}`));
+            }
+        });
+    });
+}
+/**
+ * Transcribes audio using OpenAI's Whisper API
+ */
+async function transcribeAudio(audioFilePath, apiKey, language) {
+    const openai = new OpenAI({ apiKey });
+    const audioFile = readFileSync(audioFilePath);
+    const file = new File([audioFile], "audio.wav", { type: "audio/wav" });
+    const transcription = await openai.audio.transcriptions.create({
+        file: file,
+        model: "whisper-1",
+        ...(language && { language }),
+    });
+    return transcription.text;
+}
+/**
+ * OpenCode Voice Plugin
+ *
+ * Adds a 'voice' tool that records audio from the microphone and transcribes it
+ * using OpenAI's Whisper API.
+ *
+ * @example
+ * ```ts
+ * // In opencode.json
+ * {
+ *   "plugin": ["opencode-voice"]
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With options in .opencode/plugin/voice.ts
+ * import { VoicePlugin } from "opencode-voice"
+ * export default VoicePlugin({ language: "en", defaultDuration: 10 })
+ * ```
+ */
+export const VoicePlugin = (options = {}) => async (ctx) => {
+    const { apiKey = process.env.OPENAI_API_KEY, language, defaultDuration = 5, maxDuration = 60, } = options;
+    if (!apiKey) {
+        console.warn("[Voice Plugin] Warning: OPENAI_API_KEY not set. Voice transcription will fail.");
+    }
+    return {
+        tool: {
+            voice: tool({
+                description: "Records audio from the user's microphone and transcribes it using OpenAI Whisper. " +
+                    "Use this tool when the user wants to provide input via voice or speech. " +
+                    `The tool will record for the specified duration (default ${defaultDuration} seconds) and return the transcribed text.`,
+                args: {
+                    duration: tool.schema
+                        .number()
+                        .optional()
+                        .describe(`Recording duration in seconds. Default is ${defaultDuration} seconds. Max is ${maxDuration} seconds.`),
+                },
+                async execute(args) {
+                    if (!apiKey) {
+                        return "Error: OPENAI_API_KEY environment variable is not set. Please set it to use voice transcription.";
+                    }
+                    const duration = Math.min(args.duration || defaultDuration, maxDuration);
+                    let audioFile = null;
+                    try {
+                        audioFile = await recordAudio(duration);
+                        const transcription = await transcribeAudio(audioFile, apiKey, language);
+                        if (!transcription || transcription.trim() === "") {
+                            return "No speech detected. Please try again and speak clearly into your microphone.";
+                        }
+                        return `Transcribed speech: "${transcription}"`;
+                    }
+                    catch (error) {
+                        const errorMessage = error instanceof Error ? error.message : String(error);
+                        return `Voice recording/transcription failed: ${errorMessage}`;
+                    }
+                    finally {
+                        if (audioFile) {
+                            try {
+                                unlinkSync(audioFile);
+                            }
+                            catch {
+                                // Ignore cleanup errors
+                            }
+                        }
+                    }
+                },
+            }),
+        },
+    };
+};
+// Default export for simple usage
+export default VoicePlugin();

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "speech-opencode",
+  "version": "1.0.0",
+  "description": "Voice input plugin for OpenCode using OpenAI Whisper",
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "voice",
+    "speech-to-text",
+    "whisper",
+    "openai",
+    "transcription"
+  ],
+  "author": {
+    "name": "Amitav Krishna",
+    "email": "amitavkrishna@proton.me",
+    "url": "https://amitav.net"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/amitav-krishna/speech-opencode"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "openai": "^4.77.0"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "latest",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": ">=0.1.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}