@drakulavich/parakeet-cli 0.8.0 → 0.8.1

package/bin/parakeet.js

@@ -1,4 +1,4 @@
 #!/usr/bin/env bun
-import { runMain } from "citty";
-import { mainCommand } from "../src/cli.ts";
-runMain(mainCommand);
+import { runCli } from "../src/cli.ts";
+
+await runCli();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drakulavich/parakeet-cli",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "Fast local speech-to-text CLI. CoreML on Apple Silicon, ONNX on CPU. 25 languages.",
   "type": "module",
   "bin": {

package/src/cli.ts

@@ -19,20 +19,52 @@ export function checkLanguageMismatch(expected: string | undefined, detected: st
   return `warning: expected language "${expected}" but detected "${detected}"`;
 }
 
+export interface InstallOptions {
+  coreml: boolean;
+  onnx: boolean;
+  noCache: boolean;
+}
+
+interface InstallCommandArgs {
+  coreml: boolean;
+  onnx: boolean;
+  "no-cache": boolean;
+}
+
+interface MainCommandArgs {
+  _: string[];
+  json: boolean;
+  lang?: string;
+}
+
 const pkg = await Bun.file(new URL("../package.json", import.meta.url)).json();
 
-async function performInstall(options: { coreml: boolean; onnx: boolean; noCache: boolean }) {
-  const { coreml, onnx, noCache } = options;
+export function resolveInstallBackend(options: InstallOptions, macArm64 = isMacArm64()): "coreml" | "onnx" {
+  const { coreml, onnx } = options;
+
+  if (coreml && onnx) {
+    throw new Error('Choose only one backend: "--coreml" or "--onnx".');
+  }
+
+  if (coreml) {
+    if (!macArm64) {
+      throw new Error("CoreML backend is only available on macOS Apple Silicon.");
+    }
+    return "coreml";
+  }
+
+  if (onnx) {
+    return "onnx";
+  }
+
+  return macArm64 ? "coreml" : "onnx";
+}
+
+async function performInstall(options: InstallOptions) {
+  const { noCache } = options;
   try {
-    if (coreml) {
-      if (!isMacArm64()) {
-        log.error("CoreML backend is only available on macOS Apple Silicon.");
-        process.exit(1);
-      }
-      await downloadCoreML(noCache);
-    } else if (onnx) {
-      await downloadModel(noCache);
-    } else if (isMacArm64()) {
+    const backend = resolveInstallBackend(options);
+    if (backend === "coreml") {
       await downloadCoreML(noCache);
     } else {
       await downloadModel(noCache);
@@ -66,18 +98,29 @@ export const installCommand = defineCommand({
       default: false,
     },
   },
-  async run({ args }) {
+  async run({ args }: { args: InstallCommandArgs }) {
     await performInstall({ coreml: args.coreml, onnx: args.onnx, noCache: args["no-cache"] });
   },
 });
 
+export const statusCommand = defineCommand({
+  meta: {
+    name: "status",
+    description: "Show backend installation status",
+  },
+  async run() {
+    await showStatus();
+  },
+});
+
 export const mainCommand = defineCommand({
   meta: {
     name: "parakeet",
     version: pkg.version,
     description:
       "Fast local speech-to-text. 25 languages. CoreML on Apple Silicon, ONNX on CPU.\n" +
-      "  Run 'parakeet install [--coreml | --onnx] [--no-cache]' to download models.",
+      "  Run 'parakeet install [--coreml | --onnx] [--no-cache]' to download models.\n" +
+      "  Run 'parakeet status' to inspect installed backends.",
   },
   args: {
     json: {
@@ -90,25 +133,8 @@ export const mainCommand = defineCommand({
       description: "Expected language code (ISO 639-1), warn if mismatch",
     },
   },
-  async run({ args }) {
-    const positional = args._ as string[];
-
-    // Manual subcommand routing: "parakeet install [flags]"
-    if (positional[0] === "install") {
-      const argv = process.argv;
-      const coreml = argv.includes("--coreml");
-      const onnx = argv.includes("--onnx");
-      const noCache = argv.includes("--no-cache");
-      await performInstall({ coreml, onnx, noCache });
-      return;
-    }
-
-    if (positional[0] === "status") {
-      await showStatus();
-      return;
-    }
-
-    const files = positional;
+  async run({ args }: { args: MainCommandArgs }) {
+    const files = args._;
 
     if (files.length === 0) {
       log.info("Usage: parakeet <audio_file> [audio_file ...]\n       parakeet install [--coreml | --onnx] [--no-cache]\n       parakeet status");
@@ -144,6 +170,22 @@ export const mainCommand = defineCommand({
   },
 });
 
+export async function runCli(rawArgs = process.argv.slice(2)): Promise<void> {
+  const [firstArg, ...restArgs] = rawArgs;
+
+  if (firstArg === "install") {
+    await runMain(installCommand, { rawArgs: restArgs });
+    return;
+  }
+
+  if (firstArg === "status") {
+    await runMain(statusCommand, { rawArgs: restArgs });
+    return;
+  }
+
+  await runMain(mainCommand, { rawArgs });
+}
+
 export type TranscribeResult = { file: string; text: string; lang: string };
 
 export function formatTextOutput(results: TranscribeResult[]): string {
@@ -160,5 +202,5 @@ export function formatJsonOutput(results: TranscribeResult[]): string {
 }
 
 if (import.meta.main) {
-  runMain(mainCommand);
+  await runCli();
 }

package/src/coreml-install.ts

@@ -85,6 +85,18 @@ export function getCoreMLLatestDownloadURL(): string {
   return `https://github.com/${GITHUB_REPO}/releases/latest/download/${COREML_BINARY_NAME}`;
 }
 
+export function isUnreleasedVersion(version: string): boolean {
+  return version === "0.0.0" || version.includes("-");
+}
+
+export function getCoreMLBinaryDownloadCandidates(version: string): string[] {
+  const versionUrl = getCoreMLDownloadURL(version);
+  if (isUnreleasedVersion(version)) {
+    return [getCoreMLLatestDownloadURL(), versionUrl];
+  }
+  return [versionUrl];
+}
+
 export function getCoreMLInstallState(opts?: {
   binPath?: string;
   exists?: (path: string) => boolean;
@@ -165,24 +177,21 @@ export function classifyCoreMLInstallProbe(exitCode: number, stdout: string): Co
 }
 
 async function fetchCoreMLBinary(): Promise<Response> {
-  const latestUrl = getCoreMLLatestDownloadURL();
-  let res = await fetch(latestUrl, { redirect: "follow" });
-
-  if (res.ok) {
-    return res;
-  }
-
   const pkg = await Bun.file(new URL("../package.json", import.meta.url)).json();
-  const versionUrl = getCoreMLDownloadURL(pkg.version);
-  res = await fetch(versionUrl, { redirect: "follow" });
+  const version = typeof pkg.version === "string" ? pkg.version : "unknown";
 
-  if (!res.ok) {
-    throw new Error(
-      `Failed to download CoreML binary (HTTP ${res.status})\n  No release found matching ${COREML_BINARY_NAME}\n  Fix: Check https://github.com/drakulavich/parakeet-cli/releases for available versions\n       Or install the ONNX backend instead: parakeet install --onnx`,
-    );
+  let lastStatus: number | null = null;
+  for (const url of getCoreMLBinaryDownloadCandidates(version)) {
+    const res = await fetch(url, { redirect: "follow" });
+    if (res.ok) {
+      return res;
+    }
+    lastStatus = res.status;
   }
 
-  return res;
+  throw new Error(
+    `Failed to download CoreML binary${lastStatus ? ` (HTTP ${lastStatus})` : ""}\n  Requested package version: ${version}\n  Fix: Check https://github.com/drakulavich/parakeet-cli/releases for available versions\n       Or install the ONNX backend instead: parakeet install --onnx`,
+  );
 }
 
 export function getCoreMLInstallStatus(

package/src/status.ts

@@ -4,6 +4,9 @@ import { getCoreMLInstallState, getCoreMLInstallStatus, getCoreMLSupportDir, typ
 import { log } from "./log";
 import pc from "picocolors";
 
+export type StatusCoreMLState = CoreMLInstallState | "n/a" | "probe-failed";
+export type StatusPlatform = "mac-arm64" | "other";
+
 export function formatStatusLine(
   label: string,
   path: string | null,
@@ -18,17 +21,25 @@ export function formatStatusLine(
 
 export interface StatusInfo {
   onnx: boolean;
-  coreml: CoreMLInstallState | "n/a";
+  coreml: StatusCoreMLState;
   ffmpeg: boolean;
+  platform: StatusPlatform;
 }
 
 export function collectSuggestions(info: StatusInfo): string[] {
   const suggestions: string[] = [];
 
-  if (info.coreml === "missing" || info.coreml === "stale-binary") {
-    suggestions.push(`Run "parakeet install --coreml" to install the CoreML backend.`);
-  } else if (info.coreml === "binary-only") {
-    suggestions.push(`Run "parakeet install --coreml" to download CoreML models.`);
+  if (info.platform === "mac-arm64") {
+    if (info.coreml === "missing") {
+      suggestions.push(`Run "parakeet install --coreml" to install the CoreML backend.`);
+    } else if (info.coreml === "binary-only") {
+      suggestions.push(`Run "parakeet install --coreml" to download CoreML models.`);
+    } else if (info.coreml === "stale-binary") {
+      suggestions.push(`Run "parakeet install --coreml --no-cache" to refresh the incompatible CoreML binary.`);
+    } else if (info.coreml === "probe-failed") {
+      suggestions.push(`Run "parakeet install --coreml --no-cache" to refresh the CoreML backend and restore status checks.`);
+    }
+    return suggestions;
   }
 
   if (!info.onnx) {
@@ -71,29 +82,67 @@ function defaultDeps(): StatusDeps {
   };
 }
 
+function getCoreMLBinaryDisplay(state: StatusCoreMLState): { installed: boolean; missingLabel: string } {
+  switch (state) {
+    case "ready":
+    case "binary-only":
+      return { installed: true, missingLabel: "not installed" };
+    case "stale-binary":
+      return { installed: false, missingLabel: "stale binary" };
+    case "probe-failed":
+      return { installed: false, missingLabel: "probe failed" };
+    case "missing":
+    case "n/a":
+      return { installed: false, missingLabel: "not installed" };
+  }
+}
+
+function getCoreMLModelsDisplay(state: StatusCoreMLState): { installed: boolean; missingLabel: string } {
+  switch (state) {
+    case "ready":
+      return { installed: true, missingLabel: "not installed" };
+    case "stale-binary":
+      return { installed: false, missingLabel: "reinstall required" };
+    case "probe-failed":
+      return { installed: false, missingLabel: "status unknown" };
+    case "binary-only":
+    case "missing":
+    case "n/a":
+      return { installed: false, missingLabel: "not installed" };
+  }
+}
+
 export async function showStatus(deps?: Partial<StatusDeps>): Promise<void> {
   const d = { ...defaultDeps(), ...deps };
 
   const isMac = d.isMacArm64();
+  const platform: StatusPlatform = isMac ? "mac-arm64" : "other";
 
   // CoreML status
-  let coremlState: CoreMLInstallState | "n/a" = "n/a";
+  let coremlState: StatusCoreMLState = "n/a";
+  let coremlProbeError: string | null = null;
   if (isMac) {
     const binPath = d.getCoreMLBinPath();
     try {
       coremlState = d.getCoreMLState(binPath);
-    } catch {
-      coremlState = "missing";
+    } catch (error: unknown) {
+      coremlState = "probe-failed";
+      coremlProbeError = error instanceof Error ? error.message : String(error);
     }
 
     log.info("CoreML (macOS Apple Silicon):");
-    const binInstalled = coremlState !== "missing";
-    log.info(formatStatusLine("Binary", binInstalled ? binPath : null, binInstalled));
+    const binaryDisplay = getCoreMLBinaryDisplay(coremlState);
+    log.info(formatStatusLine("Binary", coremlState === "missing" ? null : binPath, binaryDisplay.installed, binaryDisplay.missingLabel));
 
-    const modelsInstalled = coremlState === "ready";
+    const modelsDisplay = getCoreMLModelsDisplay(coremlState);
     const modelDir = d.getCoreMLSupportDir();
-    log.info(formatStatusLine("Models", modelsInstalled ? modelDir : null, modelsInstalled));
+    const modelsPath = (coremlState === "ready" || coremlState === "stale-binary" || coremlState === "probe-failed") ? modelDir : null;
+    log.info(formatStatusLine("Models", modelsPath, modelsDisplay.installed, modelsDisplay.missingLabel));
     log.info("");
+
+    if (coremlProbeError) {
+      log.warn(`CoreML status probe failed: ${coremlProbeError}`);
+    }
   }
 
   // ONNX status
@@ -117,6 +166,7 @@ export async function showStatus(deps?: Partial<StatusDeps>): Promise<void> {
     onnx: onnxInstalled,
     coreml: coremlState,
     ffmpeg: !!ffmpegPath,
+    platform,
   });
 
   for (const suggestion of suggestions) {