mia-narrative 1.0.0

package/src/engines/piper.ts

@@ -0,0 +1,134 @@
+import { spawn, execSync } from 'child_process';
+import { writeFileSync, unlinkSync, readFileSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { randomUUID } from 'crypto';
+import { Logger } from '../utils/logger.js';
+import { TTSEngine, TTSEngineConfig, GenerateAudioOptions, Voice } from './base.js';
+import { getVoiceProfile, VOICE_PROFILES } from '../config/voices.js';
+
+export class PiperEngine extends TTSEngine {
+  private piperPath: string = 'piper';
+  private modelPath: string = '';
+
+  async initialize(config: TTSEngineConfig): Promise<void> {
+    if (config.piperPath) {
+      this.piperPath = config.piperPath;
+    }
+
+    if (config.modelPath) {
+      this.modelPath = config.modelPath;
+    } else {
+      this.modelPath = process.env.MIA_NARRATIVE_PIPER_MODEL || '';
+    }
+
+    Logger.debug(`Piper engine initialized with model path: ${this.modelPath}`);
+  }
+
+  async generateAudio(options: GenerateAudioOptions): Promise<Buffer> {
+    const { text, voiceId } = options;
+
+    const voiceProfile = getVoiceProfile(voiceId);
+    if (!voiceProfile) {
+      throw new Error(`Piper voice '${voiceId}' not found.`);
+    }
+
+    if (!text || text.trim().length === 0) {
+      throw new Error('Text cannot be empty');
+    }
+
+    const tempDir = tmpdir();
+    const uid = randomUUID();
+    const textFile = join(tempDir, `piper-input-${uid}.txt`);
+    const audioFile = join(tempDir, `piper-output-${uid}.wav`);
+
+    try {
+      writeFileSync(textFile, text, 'utf-8');
+      await this.runPiper(textFile, audioFile, voiceProfile.piperModel);
+      const audioBuffer = readFileSync(audioFile);
+      return audioBuffer;
+    } finally {
+      try {
+        unlinkSync(textFile);
+        Logger.debug(`Cleaned up: ${textFile}`);
+      } catch (err) {
+        // ignore
+      }
+      try {
+        unlinkSync(audioFile);
+        Logger.debug(`Cleaned up: ${audioFile}`);
+      } catch (err) {
+        // ignore
+      }
+    }
+  }
+
+  async getVoices(): Promise<Voice[]> {
+    return Object.values(VOICE_PROFILES).map(v => ({ id: v.id, name: `${v.name} (${v.style})` }));
+  }
+
+  async isAvailable(): Promise<boolean> {
+    try {
+      if (this.piperPath === 'piper') {
+        execSync('which piper', { stdio: 'pipe' });
+      } else {
+        const { existsSync } = await import('fs');
+        if (!existsSync(this.piperPath)) {
+          return false;
+        }
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  getName(): string {
+    return 'piper';
+  }
+
+  private runPiper(
+    textFile: string,
+    outputFile: string,
+    model: string
+  ): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const args = [
+        '--model',
+        model,
+        '--output-file',
+        outputFile,
+      ];
+
+      const piper = spawn(this.piperPath, args, { stdio: ['pipe', 'ignore', 'pipe'] });
+      
+      const textContent = readFileSync(textFile, 'utf-8');
+      piper.stdin.write(textContent);
+      piper.stdin.end();
+
+      let stderr = '';
+      const MAX_STDERR_SIZE = 2048;
+
+      piper.stderr.on('data', (data) => {
+        const chunk = data.toString();
+        stderr = (stderr + chunk).slice(-MAX_STDERR_SIZE);
+      });
+
+      piper.on('close', (code) => {
+        if (code === 0) {
+          resolve();
+        } else {
+          reject(new Error(`Piper failed (exit code ${code}): ${stderr}`));
+        }
+      });
+
+      piper.on('error', (error) => {
+        reject(
+          new Error(
+            `Failed to start Piper: ${error.message}. Ensure Piper is installed and in your PATH.`
+          )
+        );
+      });
+    });
+  }
+}

package/src/types/say.d.ts

@@ -0,0 +1,26 @@
+declare module 'say' {
+  type errorCallback = (err: string | null) => void;
+  type getInstalledVoicesCallback = (err: string | null, voices: string[]) => void;
+
+  const say: {
+    speak(
+      text: string,
+      voice?: string | null,
+      speed?: number,
+      callback?: errorCallback
+    ): void;
+
+    stop(callback?: errorCallback): void;
+
+    export(
+      text: string,
+      voice: string | null,
+      speed: number,
+      filename: string,
+      callback?: errorCallback
+    ): void;
+
+    getInstalledVoices(callback?: getInstalledVoicesCallback): void;
+  };
+  export default say;
+}

package/src/utils/file-reader.ts

@@ -0,0 +1,25 @@
+import { readFileSync, existsSync } from "fs";
+import { resolve } from "path";
+import { Logger } from "./logger.js";
+
+export class FileReader {
+  static readTextFile(filePath: string): string {
+    try {
+      const absolutePath = resolve(filePath);
+      return readFileSync(absolutePath, "utf-8");
+    } catch (error) {
+      if (error instanceof Error) {
+        Logger.error(`Failed to read file: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+
+  static fileExists(filePath: string): boolean {
+    try {
+      return existsSync(filePath);
+    } catch {
+      return false;
+    }
+  }
+}

package/src/utils/logger.ts

@@ -0,0 +1,33 @@
+import chalk from "chalk";
+
+export class Logger {
+  static info(message: string): void {
+    console.log(chalk.blue("ℹ"), message);
+  }
+
+  static success(message: string): void {
+    console.log(chalk.green("✓"), message);
+  }
+
+  static error(message: string): void {
+    console.error(chalk.red("✗"), message);
+  }
+
+  static warn(message: string): void {
+    console.log(chalk.yellow("⚠"), message);
+  }
+
+  static debug(message: string): void {
+    if (process.env.DEBUG) {
+      console.log(chalk.gray("→"), message);
+    }
+  }
+
+  static log(message: string): void {
+    console.log(message);
+  }
+
+  static clear(): void {
+    console.clear();
+  }
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ES2020",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "moduleResolution": "node",
+    "typeRoots": ["./node_modules/@types", "./src/types"]
+  },
+  "include": ["bin/**/*", "src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}