@tychenjiajun/pi-voice 0.2.0 → 0.4.0

package/src/remote-asr.ts

@@ -0,0 +1,212 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Box, Container, Input, Spacer, Text, truncateToWidth } from "@earendil-works/pi-tui";
+import { VoiceKeys } from "./keybindings.js";
+import type { BackendSettings } from "./settings.js";
+import {
+  LIST_PADDING,
+  panelBorder,
+  SingleSelectPicker,
+  type SingleSelectChoice,
+} from "./ui-components.js";
+
+export type BackendType = "transcribe-cpp" | "openai-asr";
+
+/** Pick the transcription backend; shared by first-run setup and the settings menu. */
+export async function chooseBackendType(
+  ctx: ExtensionContext,
+  current: BackendSettings,
+): Promise<BackendType | undefined> {
+  const choices: SingleSelectChoice<BackendType>[] = [
+    {
+      value: "transcribe-cpp",
+      label: "Local model",
+      description: "Transcribe fully on-device with the downloaded model; works offline",
+    },
+    {
+      value: "openai-asr",
+      label: "Remote ASR (OpenAI-compatible)",
+      description:
+        "Upload audio to any OpenAI-compatible chat-completions ASR endpoint; falls back to the local model if the request fails",
+    },
+  ];
+  return ctx.ui.custom<BackendType | undefined>((tui, theme, keybindings, done) =>
+    new SingleSelectPicker(
+      tui,
+      theme,
+      keybindings,
+      choices,
+      current.type,
+      { title: "Transcription backend", cancelLabel: "back" },
+      done,
+    ),
+  );
+}
+
+function validateBaseUrl(value: string): string | undefined {
+  if (!value) return "Base URL is required";
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+      return "Base URL must start with http:// or https://";
+    }
+  } catch {
+    return "Base URL must be a valid URL";
+  }
+  return undefined;
+}
+
+function validateEnvName(value: string): string | undefined {
+  if (!value) return "Environment variable name is required";
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(value)) {
+    return "Use a plain environment variable name, e.g. OPENAI_API_KEY";
+  }
+  return undefined;
+}
+
+function remoteBackendsEqual(
+  left: Extract<BackendSettings, { type: "openai-asr" }>,
+  right: Extract<BackendSettings, { type: "openai-asr" }>,
+): boolean {
+  return (
+    left.baseUrl === right.baseUrl &&
+    left.model === right.model &&
+    left.apiKeyEnv === right.apiKeyEnv
+  );
+}
+
+/** Warn when the named variable is unset, so remote calls silently fall back to local. */
+export function warnMissingApiKey(ctx: ExtensionContext, apiKeyEnv: string): void {
+  if (process.env[apiKeyEnv]) return;
+  ctx.ui.notify(
+    `${apiKeyEnv} is not set in Pi's environment; remote transcription will fall back to the local model until it is set`,
+    "warning",
+  );
+}
+
+/**
+ * Single-field text prompt built on pi-tui's Input. Empty input may be legal
+ * (the caller decides via validate); Escape backs out of the whole flow.
+ */
+function promptText(
+  ctx: ExtensionContext,
+  options: {
+    title: string;
+    description?: string;
+    value: string;
+    placeholder?: string;
+    validate?: (value: string) => string | undefined;
+  },
+): Promise<string | undefined> {
+  return ctx.ui.custom<string | undefined>((tui, theme, keybindings, done) => {
+    const keys = new VoiceKeys(keybindings);
+    const input = new Input();
+    input.setValue(options.value);
+    let error: string | undefined;
+    const container = new Container();
+
+    const rebuild = (): void => {
+      container.clear();
+      container.addChild(panelBorder(theme));
+      container.addChild(new Spacer(1));
+      container.addChild(new Text(theme.fg("accent", theme.bold(options.title)), 1, 0));
+      if (options.description) {
+        container.addChild(new Text(theme.fg("muted", options.description), 1, 0));
+      }
+      container.addChild(new Spacer(1));
+      if (error) {
+        container.addChild(new Text(theme.fg("error", error), 1, 0));
+        container.addChild(new Spacer(1));
+      }
+      if (!input.getValue() && options.placeholder) {
+        container.addChild(new Text(theme.fg("dim", options.placeholder), 2, 0));
+      }
+      const inputBox = new Box(LIST_PADDING, 0);
+      inputBox.addChild(input);
+      container.addChild(inputBox);
+      container.addChild(new Spacer(1));
+      container.addChild(
+        new Text(
+          `${keys.hint("tui.input.submit", "save")}  ${keys.hint("tui.select.cancel", "back")}`,
+          1,
+          0,
+        ),
+      );
+      container.addChild(new Spacer(1));
+      container.addChild(panelBorder(theme));
+    };
+    rebuild();
+
+    input.onSubmit = (value) => {
+      const problem = options.validate?.(value.trim());
+      if (problem) {
+        error = problem;
+        rebuild();
+        tui.requestRender();
+        return;
+      }
+      done(value.trim());
+    };
+    input.onEscape = () => done(undefined);
+
+    return {
+      get focused() {
+        return input.focused;
+      },
+      set focused(value: boolean) {
+        input.focused = value;
+      },
+      render(width: number): string[] {
+        return container
+          .render(width)
+          .map((line) => truncateToWidth(line, width, ""));
+      },
+      handleInput(data: string): void {
+        input.handleInput(data);
+      },
+      invalidate(): void {
+        container.invalidate();
+      },
+    };
+  });
+}
+
+/**
+ * Collect base URL, model, and API key env var for an OpenAI-compatible ASR
+ * endpoint. Returns undefined if the user backs out of any field. `current`
+ * pre-fills the prompts when editing an existing backend.
+ */
+export async function promptRemoteBackend(
+  ctx: ExtensionContext,
+  current?: Extract<BackendSettings, { type: "openai-asr" }>,
+): Promise<Extract<BackendSettings, { type: "openai-asr" }> | undefined> {
+  const baseUrl = await promptText(ctx, {
+    title: "ASR base URL",
+    description: "OpenAI-compatible endpoint root, without the /chat/completions path",
+    value: current?.baseUrl ?? "",
+    placeholder: "https://api.example.com/v1",
+    validate: validateBaseUrl,
+  });
+  if (baseUrl === undefined) return undefined;
+
+  const model = await promptText(ctx, {
+    title: "ASR model",
+    value: current?.model ?? "",
+    placeholder: "whisper-1",
+    validate: (value) => (value ? undefined : "Model name is required"),
+  });
+  if (model === undefined) return undefined;
+
+  const apiKeyEnv = await promptText(ctx, {
+    title: "API key environment variable",
+    description:
+      "The key itself is read from this variable at runtime; it is never stored in settings",
+    value: current?.apiKeyEnv ?? "",
+    placeholder: "OPENAI_API_KEY",
+    validate: validateEnvName,
+  });
+  if (apiKeyEnv === undefined) return undefined;
+
+  const backend = { type: "openai-asr" as const, baseUrl, model, apiKeyEnv };
+  if (current && remoteBackendsEqual(current, backend)) return undefined;
+  return backend;
+}

package/src/runtime.ts

@@ -11,6 +11,7 @@ import { isMacOSPermissionDenied } from "./audio-errors.js";
 import { logStep, watchEventLoop } from "./log.js";
 import { DictationController } from "./dictation-controller.js";
 import { VoiceKeys } from "./keybindings.js";
+import { polishTranscript } from "./polish.js";
 import type { TranscribeSettings } from "./settings.js";
 import { displayShortcut } from "./shortcut-core.js";
 import { TranscriptionService } from "./transcription-service.js";
@@ -19,6 +20,7 @@ import type { RecordingMeter } from "./visualizer.js";
 type ActiveRecording = {
   dictation: DictationController;
   meter: RecordingMeter;
+  settings: TranscribeSettings;
   /** Ends the event-loop watch held for the whole recording. */
   unwatch: () => void;
 };
@@ -46,7 +48,7 @@ function captureErrorMessage(error: unknown): string {
 
 function transcriptionErrorMessage(error: unknown): string {
   const message = error instanceof Error ? error.message : String(error);
-  return `Local transcription failed: ${message}`;
+  return `Transcription failed: ${message}`;
 }
 
 export function createPiVoiceRuntime(
@@ -146,6 +148,8 @@ export function createPiVoiceRuntime(
       currentModelId: previous.model.id,
       microphone: previous.microphone,
       backend: previous.backend,
+      polishEnabled: previous.polishEnabled,
+      polishModel: previous.polishModel,
       postActivation: "advance",
     });
     if (configured) rememberSettings(configured);
@@ -185,12 +189,12 @@ export function createPiVoiceRuntime(
     await loadSettingsOnce();
     if (settingsReadWarning && !settings) {
       throw new Error(
-        `${settingsReadWarning} Ask the user to run /voice-settings in Pi's interactive TUI to configure a local model, then retry transcribe_file.`,
+        `${settingsReadWarning} Ask the user to run /voice-settings in Pi's interactive TUI to set up Pi Voice (a local model, and optionally a remote ASR endpoint), then retry transcribe_file.`,
       );
     }
     if (!settings) {
       throw new Error(
-        "Pi Voice is not configured. Ask the user to run /voice-settings in Pi's interactive TUI once to choose and download a local model, then retry transcribe_file.",
+        "Pi Voice is not configured. Ask the user to run /voice-settings in Pi's interactive TUI once to set up Pi Voice (choose and download a local model, and optionally a remote ASR endpoint), then retry transcribe_file.",
       );
     }
     if (!existsSync(settings.model.path)) {
@@ -293,7 +297,10 @@ export function createPiVoiceRuntime(
       if (!result) {
         await reportDictationError(ctx, active.dictation);
       } else if (result.text) {
-        ctx.ui.pasteToEditor(result.text);
+        const text = active.settings.polishEnabled
+          ? await polishTranscript(ctx, result.text, true, active.settings.polishModel)
+          : result.text;
+        ctx.ui.pasteToEditor(text);
         showTranscribeStatus(
           ctx,
           formatTranscriptionSummary(result.speechSeconds, result.transcribeSeconds),
@@ -369,7 +376,7 @@ export function createPiVoiceRuntime(
         `${rawKeyHint(stopKeys, "to transcribe")}  ${keys.hint("voice.dictation.cancel", "to discard")}`,
       );
       updateMeter();
-      recording = { dictation: controller, meter, unwatch: watchEventLoop() };
+      recording = { dictation: controller, meter, settings: configured, unwatch: watchEventLoop() };
       listenForKeys(ctx);
     } catch (error) {
       recording?.unwatch();
@@ -451,15 +458,17 @@ export function createPiVoiceRuntime(
     let reload = false;
     await runExclusive(ctx, async () => {
       await loadSettingsOnce();
-      const hadConfiguration = Boolean(settings && existsSync(settings.model.path));
-      const { configured } = await ensureSettings(ctx);
+      const { configured, completedFirstRun } = await ensureSettings(ctx);
       if (!configured) return;
-      if (!hadConfiguration) {
+      if (completedFirstRun) {
         // First-run setup ends on its Ready message rather than falling
         // straight through into the regular settings menu.
         reload = configured.shortcut !== registeredShortcut;
         return;
       }
+      // A recovered missing model file also lands here: the user asked for
+      // settings, so continue into them instead of making them run the
+      // command a second time.
       const { showSettingsMenu } = await import("./settings-menu.js");
       reload = await showSettingsMenu(pi, ctx, configured, registeredShortcut);
     });