@drakulavich/kesha-voice-kit 1.2.0 → 1.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drakulavich/kesha-voice-kit",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "Open-source voice toolkit for Apple Silicon. Speech-to-text, language detection. 25 languages.",
   "type": "module",
   "bin": {

package/src/cli.ts

@@ -4,7 +4,8 @@ import { defineCommand, runMain } from "citty";
 import { detect } from "tinyld";
 import { transcribe } from "./lib";
 import { downloadEngine } from "./engine-install";
-import { detectAudioLanguageEngine, detectTextLanguageEngine } from "./engine";
+import { detectAudioLanguageEngine, detectTextLanguageEngine, getEngineBinPath } from "./engine";
+import { readStarSeen, shouldShowStarPrompt, writeStarSeen } from "./star";
 import type { LangDetectResult } from "./engine";
 import { log } from "./log";
 import { say, SayError } from "./say";
@@ -50,6 +51,24 @@ function resolveBackendFlag(coreml: boolean, onnx: boolean): string | undefined
 }
 
 async function askForStar() {
+  // Gate on major-or-minor bump only — patch releases and re-installs of the
+  // same version shouldn't nag. First-ever install (no marker) still prompts.
+  const currentVersion = typeof pkg.version === "string" ? pkg.version : null;
+  if (!currentVersion) return;
+  const binPath = getEngineBinPath();
+  const seen = readStarSeen(binPath);
+  if (!shouldShowStarPrompt(currentVersion, seen)) {
+    return;
+  }
+  // Record the version up front so a single run never prompts twice, even
+  // if the gh subprocess below throws.
+  try {
+    writeStarSeen(binPath, currentVersion);
+  } catch {
+    // Non-fatal — falling through to the prompt is still OK, just means we
+    // may nag again on the next install if the write failed for IO reasons.
+  }
+
   const gh = Bun.which("gh");
   if (!gh) {
     log.info("\nIf you enjoy Kesha Voice Kit, consider starring the repo:");

package/src/engine-install.ts

@@ -1,11 +1,35 @@
 import { dirname } from "path";
-import { existsSync, mkdirSync, chmodSync } from "fs";
+import { existsSync, mkdirSync, chmodSync, readFileSync, writeFileSync } from "fs";
 import { getEngineBinPath, getEngineCapabilities } from "./engine";
 import { log } from "./log";
 import { streamResponseToFile } from "./progress";
 
 const GITHUB_REPO = "drakulavich/kesha-voice-kit";
 
+/**
+ * Version-marker file written next to the engine binary on download (#151).
+ * Lets `kesha install` detect a stale cached engine after a CLI upgrade and
+ * re-download without requiring `--no-cache`.
+ */
+export function getVersionMarkerPath(binPath: string): string {
+  return `${binPath}.version`;
+}
+
+/** Read the recorded version for the installed binary, or null if missing / empty. */
+export function readInstalledEngineVersion(binPath: string): string | null {
+  try {
+    const v = readFileSync(getVersionMarkerPath(binPath), "utf-8").trim();
+    return v.length > 0 ? v : null;
+  } catch {
+    // Missing, unreadable, or permission-denied → treat as no marker so we re-download.
+    return null;
+  }
+}
+
+export function writeInstalledEngineVersion(binPath: string, version: string): void {
+  writeFileSync(getVersionMarkerPath(binPath), `${version}\n`);
+}
+
 function getEngineBinaryName(): string {
   const platform = process.platform;
   const arch = process.arch;
@@ -28,21 +52,31 @@ export async function downloadEngine(
   options: InstallOptions = {},
 ): Promise<string> {
   const binPath = getEngineBinPath();
+  const pkg = await Bun.file(new URL("../package.json", import.meta.url)).json();
+  // The engine version is tracked separately from the CLI version so
+  // CLI-only patch releases don't require cutting a new GitHub release
+  // + Rust rebuild. Fall back to the CLI version for backwards compat.
+  const engineVersion =
+    typeof pkg.keshaEngine?.version === "string"
+      ? pkg.keshaEngine.version
+      : typeof pkg.version === "string"
+        ? pkg.version
+        : "unknown";
 
-  if (!noCache && existsSync(binPath)) {
-    log.success("Engine binary already installed.");
+  const installedVersion = readInstalledEngineVersion(binPath);
+  const cacheValid =
+    !noCache && existsSync(binPath) && installedVersion === engineVersion;
+
+  if (cacheValid) {
+    log.success(`Engine binary already installed (v${engineVersion}).`);
   } else {
+    // Log why we're downloading — helps diagnose surprising re-downloads.
+    if (existsSync(binPath) && installedVersion && installedVersion !== engineVersion) {
+      log.progress(
+        `Upgrading engine v${installedVersion} → v${engineVersion}...`,
+      );
+    }
     const binaryName = getEngineBinaryName();
-    const pkg = await Bun.file(new URL("../package.json", import.meta.url)).json();
-    // The engine version is tracked separately from the CLI version so
-    // CLI-only patch releases don't require cutting a new GitHub release
-    // + Rust rebuild. Fall back to the CLI version for backwards compat.
-    const engineVersion =
-      typeof pkg.keshaEngine?.version === "string"
-        ? pkg.keshaEngine.version
-        : typeof pkg.version === "string"
-        ? pkg.version
-        : "unknown";
     const url = `https://github.com/${GITHUB_REPO}/releases/download/v${engineVersion}/${binaryName}`;
 
     mkdirSync(dirname(binPath), { recursive: true });
@@ -64,7 +98,8 @@ export async function downloadEngine(
 
     await streamResponseToFile(res, binPath, "kesha-engine binary");
     chmodSync(binPath, 0o755);
-    log.success("Engine binary downloaded.");
+    writeInstalledEngineVersion(binPath, engineVersion);
+    log.success(`Engine binary downloaded (v${engineVersion}).`);
   }
 
   if (backend) {

package/src/star.ts

@@ -0,0 +1,57 @@
+import { existsSync, readFileSync, writeFileSync } from "fs";
+
+/**
+ * Version-bump gate for the "star the repo" prompt in `kesha install`.
+ *
+ * Prompts are valuable on first install and on meaningful upgrades (new
+ * features) but annoying on patch-only bumps. This module persists the
+ * last-seen version to a marker file next to the engine binary and only
+ * returns true on a major-or-minor bump.
+ */
+export function starSeenPath(binPath: string): string {
+  return `${binPath}.star-seen`;
+}
+
+export function readStarSeen(binPath: string): string | null {
+  try {
+    const v = readFileSync(starSeenPath(binPath), "utf-8").trim();
+    return v.length > 0 ? v : null;
+  } catch {
+    return null;
+  }
+}
+
+export function writeStarSeen(binPath: string, version: string): void {
+  writeFileSync(starSeenPath(binPath), `${version}\n`);
+}
+
+function parseMajorMinor(v: string): [number, number] | null {
+  const parts = v.split(".");
+  if (parts.length < 2) return null;
+  const major = Number(parts[0]);
+  const minor = Number(parts[1]);
+  if (!Number.isFinite(major) || !Number.isFinite(minor)) return null;
+  return [major, minor];
+}
+
+/**
+ * Returns true iff `current` represents a major-or-minor bump over `seen`.
+ * - `seen === null` → true (first install, always prompt once).
+ * - Same or downgraded version → false.
+ * - Patch-only bump → false (annoying on every install).
+ * - Unparseable either side → false (don't nag when we can't reason).
+ */
+export function shouldShowStarPrompt(current: string, seen: string | null): boolean {
+  if (seen === null) return true;
+  const c = parseMajorMinor(current);
+  const s = parseMajorMinor(seen);
+  if (!c || !s) return false;
+  if (c[0] > s[0]) return true;
+  if (c[0] === s[0] && c[1] > s[1]) return true;
+  return false;
+}
+
+/** True when a star-seen marker already exists for this install. */
+export function hasStarMarker(binPath: string): boolean {
+  return existsSync(starSeenPath(binPath));
+}