termux-stt 1.5.0 → 2.0.1

package/README.md

@@ -6,16 +6,16 @@
 [![npm downloads](https://img.shields.io/npm/dm/termux-stt.svg?style=flat-square&color=b91c1c)](https://www.npmjs.com/package/termux-stt)
 [![License](https://img.shields.io/badge/License-Apache_2.0-004499.svg?style=flat-square)](https://github.com/uno-km/termux-stt)
 
-> **디바이스 리소스를 활용한 통합 온디바이스 음성인식(STT) 및 순수 Python 128d X-Vector 화자 분리 프레임워크**  
-> *Unified On-Device Speech-to-Text Utilizing Device Resources & Pure Python 128d X-Vector Speaker Diarization*
+> **디바이스 리소스를 활용한 통합 온디바이스 음성인식(STT) 및 차세대 신경망 화자 분리(PyAnnote 3.0 + CAM++ 192d + TS-VAD) 프레임워크**  
+> *Unified On-Device Speech-to-Text & Neural Multi-Speaker Diarization (PyAnnote 3.0 + CAM++ 192d + TS-VAD Overlap Resolver)*
 
 ---
 
 ## Architecture & Overview
 
-Whisper.cpp, Vosk, Sherpa-ONNX 3대 네이티브 엔진을 통합하고, 닫힌 형태 순수 Python 128차원 X-Vector 클러스터링을 결합하여 80MB 미만의 초경량 메모리로 100% 온디바이스 실시간 음성인식과 화자 분리를 구현합니다.
+Whisper.cpp(네이티브 Vulkan GPU / NEON CPU) 및 Sherpa-ONNX 듀얼 모던 엔진을 통합하고, PyAnnote 3.0 신경망 세그멘테이션, 3D-Speaker CAM++ 192차원 성문 임베딩, TS-VAD 동시 발화(마이크 물림) 분리기를 결합하여 완전 온디바이스 실시간 다중 화자 음성인식을 구현합니다.
 
-Integrates Whisper.cpp, Vosk, and Sherpa-ONNX with a closed-form pure-Python 128-dimensional X-Vector clustering algorithm that operates in under 80MB RAM with zero cloud egress.
+Integrates Whisper.cpp (Native Vulkan GPU / NEON CPU) and Sherpa-ONNX with PyAnnote 3.0 neural segmentation, 3D-Speaker CAM++ 192-dim embeddings, and TS-VAD overlapped speech resolution with zero cloud egress.
 
 ---
 
@@ -28,17 +28,17 @@ pip install termux-stt
 ```python
 from termux_stt import create_engine
 
-# 1. Initialize Engine with Hybrid GPU-Encoder / CPU-Decoder Acceleration
-engine = create_engine("whisper", model="small", lang="en", threads=4, split_mode=True)
+# 1. Initialize Whisper Engine with Vulkan GPU / CPU Hybrid Acceleration
+engine = create_engine("whisper", model="small", lang="ko", threads=4, split_mode=True)
 
 # 2. Transcribe Audio directly into Subtitles
 result = engine.transcribe("samples/jfk_1min.wav")
 print("Transcript:\n", result.text)
 print("SRT Subtitles:\n", result.to_srt())
 
-# 3. 2-Speaker Diarization without PyTorch
-hybrid = create_engine("hybrid", lang="en", num_speakers=2)
-diar_result = hybrid.diarize("samples/jfk_1min.wav")
+# 3. Multi-Speaker Neural Diarization (PyAnnote 3.0 + CAM++ 192d + TS-VAD)
+hybrid = create_engine("hybrid", lang="ko", num_speakers=2)
+diar_result = hybrid.diarize("samples/kor_diarization.wav")
 for seg in diar_result.segments:
     print(f"[{seg.speaker}] ({seg.start:.1f}s -> {seg.end:.1f}s): {seg.text}")
 
@@ -53,12 +53,19 @@ const { createEngine } = require("termux-stt");
 
 async function main() {
   // 1. Initialize Whisper Engine
-  const engine = createEngine("whisper", { model: "tiny", lang: "en", threads: 4 });
+  const engine = createEngine("whisper", { model: "tiny", lang: "ko", threads: 4 });
 
   // 2. Transcribe Audio
   const result = await engine.transcribe("samples/jfk_1min.wav");
   console.log("Transcript:", result.text);
   console.log("SRT Subtitles:\n", result.toSrt());
+
+  // 3. Neural Diarization via Hybrid Engine
+  const hybrid = createEngine("hybrid", { lang: "ko", numSpeakers: 2 });
+  const diarResult = await hybrid.diarize("samples/kor_diarization.wav");
+  for (const seg of diarResult.segments) {
+    console.log(`[${seg.speaker}] (${seg.start.toFixed(1)}s -> ${seg.end.toFixed(1)}s): ${seg.text}`);
+  }
 }
 main();
 
@@ -66,46 +73,6 @@ main();
 
 ---
 
-## Distributed Clustering & Memory Pooling (AMEVA-Cluster)
-
-Termux-STT natively integrates with **AMEVA-Cluster** (`pip install ameva-cluster`) for distributed large-model speech recognition (e.g. `whisper-large-v3-turbo`) across interconnected mobile fleets.
-
-### 1. Install Cluster Runtime
-```bash
-pip install ameva-cluster
-# or Node.js:
-npm install @ameva/cluster
-```
-
-### 2. Launch Worker Node on Remote Phone
-```bash
-# On remote worker device (e.g. Galaxy A53):
-ameva-cluster worker --port 50052
-```
-
-### 3. Distributed Transcription via Master Node
-```bash
-# Master node sharding Whisper-Large layers across remote phone RAM:
-termux-stt transcribe meeting.wav \
-  --model whisper-large-v3-turbo.bin \
-  --rpc 192.0.2.10:50052,192.0.2.11:50052
-```
-
-```python
-from termux_stt import create_engine
-
-# Python SDK Distributed STT
-engine = create_engine(
-    "whisper",
-    model="large-v3-turbo",
-    cluster_rpc_servers="192.0.2.10:50052,192.0.2.11:50052"
-)
-result = engine.transcribe("meeting.wav")
-print(result.text)
-```
-
----
-
 ## Official Documentation & Benchmarks
 - [Official Architecture & API Reference](https://uno-km.vercel.app/lib/stt/)
 - [Ecosystem Metrics & Registry Stats](https://uno-km.vercel.app/foundation/metrics)

package/README.pypi.md

@@ -4,7 +4,7 @@
 [![Python](https://img.shields.io/pypi/pyversions/termux-stt.svg?style=flat-square)](https://pypi.org/project/termux-stt/)
 [![License](https://img.shields.io/badge/License-Apache_2.0-004499.svg?style=flat-square)](https://github.com/uno-km/termux-stt)
 
-> Unified On-Device Speech-to-Text Utilizing Device Resources & Pure Python 128d X-Vector Speaker Diarization
+> Unified On-Device Speech-to-Text & Neural Multi-Speaker Diarization (PyAnnote 3.0 + CAM++ 192d + TS-VAD Overlap Resolver)
 
 ## Installation
 
@@ -17,24 +17,24 @@ pip install termux-stt
 ```python
 from termux_stt import create_engine
 
-# 1. Initialize Engine with Hybrid GPU-Encoder / CPU-Decoder Acceleration
-engine = create_engine("whisper", model="small", lang="en", threads=4, split_mode=True)
+# 1. Initialize Whisper Engine with Vulkan GPU / CPU Hybrid Acceleration
+engine = create_engine("whisper", model="small", lang="ko", threads=4, split_mode=True)
 
 # 2. Transcribe Audio directly into Subtitles
 result = engine.transcribe("samples/jfk_1min.wav")
 print("Transcript:\n", result.text)
 print("SRT Subtitles:\n", result.to_srt())
 
-# 3. 2-Speaker Diarization without PyTorch
-hybrid = create_engine("hybrid", lang="en", num_speakers=2)
-diar_result = hybrid.diarize("samples/jfk_1min.wav")
+# 3. Multi-Speaker Neural Diarization (PyAnnote 3.0 + CAM++ 192d + TS-VAD)
+hybrid = create_engine("hybrid", lang="ko", num_speakers=2)
+diar_result = hybrid.diarize("samples/kor_diarization.wav")
 for seg in diar_result.segments:
     print(f"[{seg.speaker}] ({seg.start:.1f}s -> {seg.end:.1f}s): {seg.text}")
 
 ```
 
 ## Description
-Integrates Whisper.cpp, Vosk, and Sherpa-ONNX with a closed-form pure-Python 128-dimensional X-Vector clustering algorithm that operates in under 80MB RAM with zero cloud egress.
+Integrates Whisper.cpp (Native Vulkan GPU / NEON CPU) and Sherpa-ONNX with PyAnnote 3.0 neural segmentation, 3D-Speaker CAM++ 192-dim embeddings, and TS-VAD overlapped speech resolution with zero cloud egress.
 
 ## Documentation
 - [Official Documentation & API Reference](https://uno-km.vercel.app/lib/stt/)

package/index.d.ts

@@ -45,7 +45,7 @@ export class WhisperEngine extends Engine {
   diarize(audioPath: string, numSpeakers?: number): Promise<TranscriptResult>;
 }
 
-export class VoskEngine extends Engine {
+export class SherpaEngine extends Engine {
   transcribe(audioPath: string, options?: any): Promise<TranscriptResult>;
   diarize(audioPath: string, numSpeakers?: number): Promise<TranscriptResult>;
 }
@@ -56,8 +56,13 @@ export class HybridEngine extends Engine {
 }
 
 export function createEngine(
-  engineName?: 'whisper' | 'vosk' | 'hybrid' | string,
+  engineName?: 'whisper' | 'sherpa' | 'hybrid' | string,
   options?: EngineOptions
 ): Engine;
 
-export function formatTime(seconds: number, separator?: string): string;
+export class TermuxSTT {
+  engine: Engine;
+  constructor(options?: EngineOptions & { engine?: string });
+  transcribe(filePath: string, options?: any): Promise<TranscriptResult>;
+  diarize(filePath: string, options?: any): Promise<TranscriptResult>;
+}

package/index.js

@@ -1,10 +1,10 @@
 /**
- * termux-stt Node.js entry point
+ * termux-stt Node.js entry point (v2.0.0)
  */
 
 const { Engine, TranscriptResult, Segment, formatTime } = require('./lib/engine');
 const { WhisperEngine } = require('./lib/whisper');
-const { VoskEngine } = require('./lib/vosk');
+const { SherpaEngine } = require('./lib/sherpa');
 const { HybridEngine } = require('./lib/hybrid');
 
 function createEngine(engineName = 'whisper', options = {}) {
@@ -12,12 +12,14 @@ function createEngine(engineName = 'whisper', options = {}) {
   switch (name) {
     case 'whisper':
       return new WhisperEngine(options);
-    case 'vosk':
-      return new VoskEngine(options);
+    case 'sherpa':
+      return new SherpaEngine(options);
     case 'hybrid':
       return new HybridEngine(options);
+    case 'vosk':
+      throw new Error("Vosk has been deprecated and completely removed in v2.0.0. Please use 'sherpa' (SenseVoice) or 'whisper'.");
     default:
-      throw new Error(`Unknown engine: ${engineName}. Available: whisper, vosk, hybrid`);
+      throw new Error(`Unknown engine: ${engineName}. Available: whisper, sherpa, hybrid`);
   }
 }
 
@@ -41,7 +43,7 @@ module.exports = {
   TranscriptResult,
   Segment,
   WhisperEngine,
-  VoskEngine,
+  SherpaEngine,
   HybridEngine,
   formatTime
 };

package/lib/hybrid.js

@@ -53,7 +53,7 @@ class HybridEngine extends Engine {
 
   getInfo() {
     return {
-      name: 'Hybrid Vosk+Whisper (Node.js)',
+      name: 'Hybrid Neural Diarizer + Whisper (Node.js)',
       model: this.model,
       language: this.lang,
       numSpeakers: this.numSpeakers

package/lib/sherpa.js

@@ -0,0 +1,97 @@
+/**
+ * SherpaEngine for Node.js - Non-Autoregressive SenseVoice STT & Neural Diarization
+ */
+
+const { spawn } = require('child_process');
+const { Engine, TranscriptResult, Segment } = require('./engine');
+
+class SherpaEngine extends Engine {
+  constructor(config = {}) {
+    super(config);
+    this.model = config.model || 'sensevoice-small-int8';
+    this.lang = config.lang || 'ko';
+    this.threads = config.threads || 4;
+  }
+
+  async transcribe(audioPath, options = {}) {
+    return new Promise((resolve, reject) => {
+      const args = [
+        '-m', 'termux_stt.cli.main',
+        'transcribe',
+        '--engine', 'sherpa',
+        '--model', this.model,
+        '--lang', this.lang,
+        '--format', 'json',
+        audioPath
+      ];
+
+      const proc = spawn('python', args, { env: process.env });
+      let stdout = '';
+      let stderr = '';
+
+      proc.stdout.on('data', (d) => { stdout += d.toString(); });
+      proc.stderr.on('data', (d) => { stderr += d.toString(); });
+
+      proc.on('close', (code) => {
+        if (code !== 0) {
+          return reject(new Error(`Sherpa transcription failed (code ${code}): ${stderr}`));
+        }
+        try {
+          const parsed = JSON.parse(stdout);
+          const segments = (parsed.segments || []).map(
+            s => new Segment(s.start, s.end, s.text, s.speaker, s.confidence)
+          );
+          resolve(new TranscriptResult(parsed.text, segments, parsed.language || this.lang, parsed.duration));
+        } catch (e) {
+          resolve(new TranscriptResult(stdout.trim(), [new Segment(0, 0, stdout.trim())], this.lang));
+        }
+      });
+    });
+  }
+
+  async diarize(audioPath, numSpeakers = 2) {
+    return new Promise((resolve, reject) => {
+      const args = [
+        '-m', 'termux_stt.cli.main',
+        'diarize',
+        '--engine', 'sherpa',
+        '--speakers', String(numSpeakers),
+        '--format', 'json',
+        audioPath
+      ];
+
+      const proc = spawn('python', args, { env: process.env });
+      let stdout = '';
+      let stderr = '';
+
+      proc.stdout.on('data', (d) => { stdout += d.toString(); });
+      proc.stderr.on('data', (d) => { stderr += d.toString(); });
+
+      proc.on('close', (code) => {
+        if (code !== 0) {
+          return reject(new Error(`Sherpa diarization failed (code ${code}): ${stderr}`));
+        }
+        try {
+          const parsed = JSON.parse(stdout);
+          const segments = (parsed.segments || []).map(
+            s => new Segment(s.start, s.end, s.text, s.speaker, s.confidence)
+          );
+          resolve(new TranscriptResult(parsed.text, segments, parsed.language || this.lang, parsed.duration));
+        } catch (e) {
+          resolve(new TranscriptResult(stdout.trim(), [new Segment(0, 0, stdout.trim())], this.lang));
+        }
+      });
+    });
+  }
+
+  getInfo() {
+    return {
+      name: 'Sherpa-ONNX (Node.js)',
+      model: this.model,
+      language: this.lang,
+      threads: this.threads
+    };
+  }
+}
+
+module.exports = { SherpaEngine };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "termux-stt",
-  "version": "1.5.0",
-  "description": "On-device Speech-to-Text & speaker diarization framework utilizing device resources for Android Termux",
+  "version": "2.0.1",
+  "description": "On-device Speech-to-Text & neural speaker diarization framework for Android Termux (Whisper Vulkan GPU & Sherpa-ONNX)",
   "main": "index.js",
   "types": "index.d.ts",
   "bin": {

package/lib/vosk.js

@@ -1,60 +0,0 @@
-/**
- * VoskEngine for Node.js
- */
-
-const { spawn } = require('child_process');
-const { Engine, TranscriptResult, Segment } = require('./engine');
-
-class VoskEngine extends Engine {
-  constructor(config = {}) {
-    super(config);
-    this.model = config.model || 'small-ko-0.22';
-    this.lang = config.lang || 'ko';
-  }
-
-  async transcribe(audioPath, options = {}) {
-    return new Promise((resolve, reject) => {
-      const args = [
-        '-m', 'termux_stt.cli.main',
-        'transcribe',
-        '--engine', 'vosk',
-        '--model', this.model,
-        '--lang', this.lang,
-        '--format', 'json',
-        audioPath
-      ];
-
-      const proc = spawn('python', args, { env: process.env });
-      let stdout = '';
-      let stderr = '';
-
-      proc.stdout.on('data', (d) => { stdout += d.toString(); });
-      proc.stderr.on('data', (d) => { stderr += d.toString(); });
-
-      proc.on('close', (code) => {
-        if (code !== 0) {
-          return reject(new Error(`Vosk transcription failed (code ${code}): ${stderr}`));
-        }
-        try {
-          const parsed = JSON.parse(stdout);
-          const segments = (parsed.segments || []).map(
-            s => new Segment(s.start, s.end, s.text, s.speaker, s.confidence)
-          );
-          resolve(new TranscriptResult(parsed.text, segments, parsed.language || this.lang, parsed.duration));
-        } catch (e) {
-          resolve(new TranscriptResult(stdout.trim(), [new Segment(0, 0, stdout.trim())], this.lang));
-        }
-      });
-    });
-  }
-
-  getInfo() {
-    return {
-      name: 'Vosk (Node.js)',
-      model: this.model,
-      language: this.lang
-    };
-  }
-}
-
-module.exports = { VoskEngine };