@drakulavich/parakeet-cli 0.2.0 → 0.4.0

package/package.json

@@ -1,11 +1,15 @@
 {
   "name": "@drakulavich/parakeet-cli",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Fast multilingual speech-to-text CLI powered by NVIDIA Parakeet ONNX models",
   "type": "module",
   "bin": {
     "parakeet": "bin/parakeet.js"
   },
+  "exports": {
+    ".": "./src/cli.ts",
+    "./core": "./src/lib.ts"
+  },
   "files": [
     "bin/",
     "src/",

package/src/__tests__/lib.test.ts

@@ -0,0 +1,12 @@
+import { describe, expect, it } from "bun:test";
+import { transcribe } from "../lib";
+
+describe("lib API", () => {
+  it("exports transcribe function", () => {
+    expect(typeof transcribe).toBe("function");
+  });
+
+  it("rejects missing file", async () => {
+    await expect(transcribe("/nonexistent/audio.wav")).rejects.toThrow("File not found");
+  });
+});

package/src/cli.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 
-import { existsSync } from "fs";
-import { transcribe } from "./transcribe";
+import { transcribe } from "./lib";
+import { downloadModel } from "./models";
 
 async function main(): Promise<void> {
   const args = process.argv.slice(2);
@@ -12,25 +12,34 @@ async function main(): Promise<void> {
     process.exit(0);
   }
 
-  const noCache = args.includes("--no-cache");
-  const file = args.filter((a) => !a.startsWith("--"))[0];
-
-  if (!file) {
-    console.error("Usage: parakeet [--no-cache] <audio_file>");
-    process.exit(1);
+  const positional = args.filter((a) => !a.startsWith("--"));
+
+  if (positional[0] === "install") {
+    const noCache = args.includes("--no-cache");
+    try {
+      await downloadModel(noCache);
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`Error: ${message}`);
+      process.exit(1);
+    }
+    process.exit(0);
   }
 
-  if (!existsSync(file)) {
-    console.error(`Error: file not found: ${file}`);
+  const file = positional[0];
+
+  if (!file) {
+    console.error("Usage: parakeet [--version] <audio_file>");
+    console.error("       parakeet install [--no-cache]");
     process.exit(1);
   }
 
   try {
-    const text = await transcribe(file, { noCache });
+    const text = await transcribe(file);
     if (text) process.stdout.write(text + "\n");
   } catch (err: unknown) {
     const message = err instanceof Error ? err.message : String(err);
-    console.error(`Error: ${message}`);
+    console.error(message);
     process.exit(1);
   }
 }

package/src/lib.ts

@@ -0,0 +1,17 @@
+import { existsSync } from "fs";
+import { transcribe as internalTranscribe, type TranscribeOptions } from "./transcribe";
+import { downloadModel } from "./models";
+
+export type { TranscribeOptions };
+export { downloadModel };
+
+export async function transcribe(
+  audioPath: string,
+  options: TranscribeOptions = {},
+): Promise<string> {
+  if (!existsSync(audioPath)) {
+    throw new Error(`File not found: ${audioPath}`);
+  }
+
+  return internalTranscribe(audioPath, options);
+}

package/src/models.ts

@@ -16,15 +16,36 @@ export function getModelDir(): string {
   return join(homedir(), ".cache", "parakeet", "v3");
 }
 
-export function isModelCached(): boolean {
-  const dir = getModelDir();
-  return MODEL_FILES.every((f) => existsSync(join(dir, f)));
+export function isModelCached(dir?: string): boolean {
+  const d = dir ?? getModelDir();
+  return MODEL_FILES.every((f) => existsSync(join(d, f)));
 }
 
-export async function ensureModel(noCache = false): Promise<string> {
-  const dir = getModelDir();
+export function requireModel(modelDir?: string): string {
+  const dir = modelDir ?? getModelDir();
 
-  if (!noCache && isModelCached()) {
+  if (!isModelCached(dir)) {
+    const lines = [
+      `Error: Model not found at ${dir}`,
+      "",
+      "╔══════════════════════════════════════════════════════════╗",
+      "║ Looks like Parakeet model is not downloaded yet.         ║",
+      "║ Please run the following command to download the model:  ║",
+      "║                                                          ║",
+      "║     npx @drakulavich/parakeet-cli install                ║",
+      "╚══════════════════════════════════════════════════════════╝",
+    ];
+    throw new Error(lines.join("\n"));
+  }
+
+  return dir;
+}
+
+export async function downloadModel(noCache = false, modelDir?: string): Promise<string> {
+  const dir = modelDir ?? getModelDir();
+
+  if (!noCache && isModelCached(dir)) {
+    console.error("Model already downloaded.");
     return dir;
   }
 
@@ -47,5 +68,6 @@ export async function ensureModel(noCache = false): Promise<string> {
     await Bun.write(dest, res);
   }
 
+  console.error("Model downloaded successfully.");
   return dir;
 }

package/src/transcribe.ts

@@ -1,4 +1,4 @@
-import { ensureModel } from "./models";
+import { requireModel } from "./models";
 import { convertToFloat32PCM } from "./audio";
 import { initPreprocessor, preprocess } from "./preprocess";
 import { initEncoder, encode } from "./encoder";
@@ -25,7 +25,8 @@ const DECODER_LAYERS = 2;
 const DECODER_HIDDEN = 640;
 
 export interface TranscribeOptions {
-  noCache?: boolean;
+  beamWidth?: number;
+  modelDir?: string;
 }
 
 // Minimum 0.1s of audio at 16kHz to produce meaningful output
@@ -38,8 +39,8 @@ export async function transcribe(audioPath: string, opts: TranscribeOptions = {}
     return "";
   }
 
-  const noCache = opts.noCache ?? false;
-  const modelDir = await ensureModel(noCache);
+  const beamWidth = opts.beamWidth ?? 4;
+  const modelDir = requireModel(opts.modelDir);
   const tokenizer = await Tokenizer.fromFile(join(modelDir, "vocab.txt"));
 
   await initPreprocessor(modelDir);
@@ -63,6 +64,6 @@ export async function transcribe(audioPath: string, opts: TranscribeOptions = {}
     DECODER_HIDDEN,
   );
 
-  const tokens = await beamDecode(session, encodedLength, transposed, D);
+  const tokens = await beamDecode(session, encodedLength, transposed, D, beamWidth);
   return tokenizer.detokenize(tokens);
 }