@drakulavich/kesha-voice-kit 1.24.3 → 1.24.5

package/bin/kesha.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drakulavich/kesha-voice-kit",
-  "version": "1.24.3",
+  "version": "1.24.5",
   "description": "Give your tools a voice — speech to text and back, 25 languages, up to ~19× faster than Whisper. On your machine.",
   "type": "module",
   "bin": {
@@ -38,7 +38,7 @@
     }
   },
   "keshaEngine": {
-    "version": "1.24.3"
+    "version": "1.24.5"
   },
   "scripts": {
     "test": "bun test",
@@ -52,7 +52,6 @@
     "coverage:check:rust": "bun .github/scripts/check-coverage.ts --preset=rust --lcov=coverage/rust/lcov.info --summary=coverage/rust/summary.md",
     "generate:shell-artifacts": "bun scripts/generate-shell-artifacts.ts",
     "lint": "bunx tsc --noEmit",
-    "lint:tsgo": "bunx tsgo --noEmit",
     "check": "bun run lint && bun run check:versions && bun run test:cli-fast",
     "check:workflows": "bun .github/scripts/check-workflows.ts",
     "check:release-manifest": "bun .github/scripts/release-manifest.mjs --check",
@@ -85,9 +84,8 @@
   },
   "devDependencies": {
     "@types/bun": "latest",
-    "@typescript/native-preview": "^7.0.0-dev.20260423.1",
     "fast-xml-parser": "^5.8.0",
-    "typescript": "^6.0.2",
+    "typescript": "^7.0.2",
     "yaml": "^2.9.0"
   },
   "dependencies": {
@@ -99,5 +97,8 @@
     "picocolors": "^1.1.1",
     "tinyld": "^1.3.4",
     "zod": "^4.4.3"
+  },
+  "overrides": {
+    "hono": "^4.12.25"
   }
 }

package/src/cli/dispatch.ts

@@ -2,37 +2,23 @@ import { runMain, type CommandDef } from "citty";
 import { existsSync } from "fs";
 import { log, setColorEnabled } from "../log";
 import { suggestCommand } from "../suggest-command";
-import { completionsCommand } from "./completions";
-import { doctorCommand } from "./doctor";
-import { initCommand } from "./init";
-import { installCommand } from "./install";
-import { logsCommand } from "./logs";
-import { manpageCommand } from "./manpage";
-import { recordCommand } from "./record";
-import { sayCommand } from "./say";
-import { statsCommand } from "./stats";
-import { statusCommand } from "./status";
-import { supportBundleCommand } from "./support-bundle";
-import { mainCommand } from "./main";
-import { mcpCommand } from "./mcp";
 
-// Single source of truth: keyed lookup also feeds the `did you mean` suggester.
-// `CommandDef<any>` is intentional — citty's generic is invariant in the args
-// shape, and each subcommand has its own arg schema; the value here is only
-// passed back to `runMain`, which re-reads the schema from the def itself.
-const SUBCOMMANDS: Record<string, CommandDef<any>> = {
-  doctor: doctorCommand,
-  init: initCommand,
-  install: installCommand,
-  logs: logsCommand,
-  status: statusCommand,
-  record: recordCommand,
-  say: sayCommand,
-  stats: statsCommand,
-  "support-bundle": supportBundleCommand,
-  completions: completionsCommand,
-  manpage: manpageCommand,
-  mcp: mcpCommand,
+// Lazy loaders so a cold CLI spawn transpiles only the invoked command, not the whole graph (#568).
+// `CommandDef<any>`: citty's generic is invariant in the arg shape and each command has its own schema.
+type CommandLoader = () => Promise<CommandDef<any>>;
+const SUBCOMMANDS: Record<string, CommandLoader> = {
+  doctor: async () => (await import("./doctor")).doctorCommand,
+  init: async () => (await import("./init")).initCommand,
+  install: async () => (await import("./install")).installCommand,
+  logs: async () => (await import("./logs")).logsCommand,
+  status: async () => (await import("./status")).statusCommand,
+  record: async () => (await import("./record")).recordCommand,
+  say: async () => (await import("./say")).sayCommand,
+  stats: async () => (await import("./stats")).statsCommand,
+  "support-bundle": async () => (await import("./support-bundle")).supportBundleCommand,
+  completions: async () => (await import("./completions")).completionsCommand,
+  manpage: async () => (await import("./manpage")).manpageCommand,
+  mcp: async () => (await import("./mcp")).mcpCommand,
 };
 
 function isPathLike(arg: string): boolean {
@@ -46,9 +32,7 @@ function isFalsey(v: string): boolean {
   return FALSEY_VALUES.has(v.trim().toLowerCase());
 }
 
-// Whether the process was launched with NO_COLOR already forced on. Captured
-// once at import (before any runCli) so re-enabling colors never clobbers an
-// externally-set NO_COLOR — we only clear the var on re-enable when WE set it.
+// Captured at import so re-enabling colors never clobbers a user-exported NO_COLOR.
 const USER_FORCED_NO_COLOR =
   process.env.NO_COLOR !== undefined && !isFalsey(process.env.NO_COLOR);
 
@@ -105,47 +89,72 @@ export function resolveQuietMode(rawArgs: string[]): { quiet: boolean; rawArgs:
   return { quiet: value, rawArgs: cleaned };
 }
 
-export async function runCli(rawArgs = process.argv.slice(2)): Promise<void> {
-  // Global flags resolved before citty so they apply to every command (and help
-  // output) and never reach a subcommand's arg schema.
-  const color = resolveColorMode(rawArgs);
-  // Reset on EVERY invocation (not just the disable path): an earlier
-  // --no-color / CI call must not leave colors permanently off for later
-  // in-process calls (unit tests, `kesha mcp`). picocolors already honors
-  // NO_COLOR at startup; setting the env var also propagates to the engine.
-  setColorEnabled(!color.disableColor);
-  // Keep NO_COLOR symmetric so it doesn't leak to engine subprocesses spawned
-  // by a later in-process call: set it when WE disable, clear it on re-enable —
-  // but never clear a NO_COLOR the user exported themselves.
-  if (color.disableColor) {
+/**
+ * Sync NO_COLOR with the resolved color decision so engine subprocesses inherit
+ * the right value. Separated from setColorEnabled so it can be tested without
+ * picocolors side-effects.
+ *
+ * Never clears a NO_COLOR the user exported before this process started
+ * (USER_FORCED_NO_COLOR guard).
+ */
+export function applyColorEnv(disableColor: boolean): void {
+  if (disableColor) {
     process.env.NO_COLOR = "1";
   } else if (!USER_FORCED_NO_COLOR) {
     delete process.env.NO_COLOR;
   }
+}
+
+/**
+ * Classify the first positional arg for routing.
+ *
+ * - `"subcommand"` — exact match in the known subcommand set
+ * - `"unknown"`    — bare token that looks like a typo (not a flag, not path-like)
+ * - `"main"`       — flags, path-like args, or no arg (→ transcribe / help)
+ */
+export function classifyFirstArg(
+  firstArg: string | undefined,
+  subcommandKeys: string[],
+): "subcommand" | "unknown" | "main" {
+  if (!firstArg) return "main";
+  if (subcommandKeys.includes(firstArg)) return "subcommand";
+  // Flags and path-like tokens fall through to the main transcribe command.
+  if (firstArg.startsWith("-") || isPathLike(firstArg)) return "main";
+  return "unknown";
+}
+
+export async function runCli(rawArgs = process.argv.slice(2)): Promise<void> {
+  // Global flags resolved before citty so they apply to every command and never reach a subcommand's arg schema.
+  const color = resolveColorMode(rawArgs);
+  // Reset on every invocation so an earlier --no-color/CI call doesn't leave colors off for later in-process calls (unit tests, `kesha mcp`).
+  setColorEnabled(!color.disableColor);
+  applyColorEnv(color.disableColor);
 
   const quiet = resolveQuietMode(color.rawArgs);
   log.quietEnabled = quiet.quiet;
 
   rawArgs = quiet.rawArgs;
   const [firstArg, ...restArgs] = rawArgs;
+  const subcommandKeys = Object.keys(SUBCOMMANDS);
 
-  if (firstArg && Object.hasOwn(SUBCOMMANDS, firstArg)) {
-    await runMain(SUBCOMMANDS[firstArg], { rawArgs: restArgs });
-    return;
-  }
+  switch (classifyFirstArg(firstArg, subcommandKeys)) {
+    case "subcommand":
+      await runMain(await SUBCOMMANDS[firstArg!]!(), { rawArgs: restArgs });
+      return;
 
-  // Check for unknown subcommands (non-flag, non-file-path args).
-  // Extensionless existing files remain valid transcription inputs; missing
-  // bare tokens are more likely command typos and should not start the engine.
-  if (firstArg && !firstArg.startsWith("-") && !isPathLike(firstArg)) {
-    const suggestion = suggestCommand(firstArg, Object.keys(SUBCOMMANDS));
-    log.error(`unknown command '${firstArg}'`);
-    if (suggestion && suggestion !== firstArg) {
-      log.warn(`(Did you mean ${suggestion}?)`);
+    case "unknown": {
+      // Extensionless existing files are valid transcription inputs; bare non-path tokens are likely command typos.
+      const suggestion = suggestCommand(firstArg!, subcommandKeys);
+      log.error(`unknown command '${firstArg}'`);
+      if (suggestion && suggestion !== firstArg) {
+        log.warn(`(Did you mean ${suggestion}?)`);
+      }
+      log.warn(`If this is an audio file, pass a path like './${firstArg}'.`);
+      process.exit(1);
+      break;
     }
-    log.warn(`If this is an audio file, pass a path like './${firstArg}'.`);
-    process.exit(1);
-  }
 
-  await runMain(mainCommand, { rawArgs });
+    default:
+      await runMain((await import("./main")).mainCommand, { rawArgs });
+  }
 }

package/src/cli/init.ts

@@ -5,12 +5,8 @@ import { multiselect, isCancel, cancel } from "@clack/prompts";
 import { renderInstallPlan } from "../install-plan";
 import { log } from "../log";
 import { getEngineCapabilities } from "../engine";
-import {
-  performInstall,
-  resolveBackendFlag,
-  resolveNoCacheFlag,
-  TTS_LANG_FALLBACK,
-} from "./install";
+import { performInstall, resolveBackendFlag, resolveNoCacheFlag, TTS_LANG_FALLBACK } from "./install";
+import type { SharedInstallArgs } from "./types";
 
 const TTS_LANG_LABELS: Record<string, string> = {
   en: "English (Kokoro)",
@@ -44,16 +40,7 @@ async function promptTtsLangs(preselect: string[]): Promise<string[]> {
   return selected as string[];
 }
 
-export interface InitCommandArgs {
-  coreml: boolean;
-  onnx: boolean;
-  "no-cache": boolean;
-  noCache?: boolean;
-  no_cache?: boolean;
-  tts: boolean;
-  vad: boolean;
-  diarize: boolean;
-  plan: boolean;
+export interface InitCommandArgs extends SharedInstallArgs {
   yes: boolean;
 }
 

package/src/cli/install.ts

@@ -7,19 +7,11 @@ import { maybeAskForStar } from "../star";
 import { log } from "../log";
 import { packageVersion } from "../package-info";
 import { createDiagnosticLogSession, type DiagnosticLogSession } from "../diagnostic-log";
+import type { SharedInstallArgs } from "./types";
 
-export interface InstallCommandArgs {
+export interface InstallCommandArgs extends SharedInstallArgs {
   /** Positional args after `install` — candidate TTS language codes. */
   _?: string[];
-  coreml: boolean;
-  onnx: boolean;
-  "no-cache": boolean;
-  noCache?: boolean;
-  no_cache?: boolean;
-  tts: boolean;
-  vad: boolean;
-  diarize: boolean;
-  plan: boolean;
 }
 
 /**
@@ -30,9 +22,7 @@ export interface InstallCommandArgs {
 export const TTS_LANG_FALLBACK = ["en", "es", "fr", "it", "pt", "ru"];
 
 export interface TtsArgInput {
-  /** Whether --tts was passed. */
   tts: boolean;
-  /** Positional args after the install command (candidate language codes). */
   positionals: string[];
 }