@wovin/tranz-cli 0.0.26

package/dist/commands/prep/index.js

@@ -0,0 +1,177 @@
+var _a;
+import { Command, Flags, CliUx } from '@oclif/core';
+import ffmpeg from 'fluent-ffmpeg';
+import * as fs from 'node:fs';
+import { getFileInfo, getName, getNameWithExt } from "../../utils/file-utils.js";
+// @ts-expect-error
+import normalize from '@dharmendrasha/ffmpeg-normalize';
+import path from 'node:path';
+const doSilenceRemoval = async (inputPath, silence, sildur, output = `${inputPath}-silenceRemoved.mp3`) => {
+    ffmpeg(inputPath, { logger: console })
+        .audioFilters([
+        {
+            filter: 'silenceremove',
+            options: { stop_threshold: silence, stop_periods: -1, stop_duration: sildur, /* stop_silence: 0.25,  start_silence: 0.25 */ }
+        }
+    ])
+        .on('codecData', function (data) {
+        // console.log('Input is ' + data.audio + ' audio ' + 'with ' + data.video + ' video');
+    })
+        .on('stderr', function (stderrLine) {
+        console.log('Stderr output: ' + stderrLine);
+    })
+        .on('error', function (error) {
+        console.error('Error:', error, silence);
+    })
+        .on('end', function (stdout, stderr) {
+        console.log('Silence Removal succeeded,  output path:', output);
+    })
+        .save(output);
+};
+const doNormalization = async (path, outputDir) => {
+    // const [name, ext] = getExt(path) as string[]
+    const { name, ext } = getFileInfo(path);
+    const output = `${outputDir}/${name}_normalized${ext}`;
+    const normalized = await normalize({
+        input: path,
+        output,
+        loudness: {
+            normalization: 'ebuR128',
+            target: {
+                input_i: -23,
+                input_lra: 7.0,
+                input_tp: -2.0
+            }
+        }
+    }).catch((error) => {
+        // Some error happened
+        console.error(error);
+    });
+    console.log(normalized);
+    const finalOutputPath = `${outputDir}/${getName(output)}-prepared.wav`;
+    return new Promise(resolveFx => {
+        ffmpeg(output, { logger: console })
+            .audioFrequency(16000) // required for whisper
+            .outputOptions(['-ac 1', '-c:a pcm_s16le'])
+            .save(finalOutputPath)
+            .on('end', () => {
+            resolveFx(finalOutputPath);
+        });
+    });
+};
+class Prep extends Command {
+    /**
+     * doPrep
+     */
+    async doPrep(props) {
+        const { input, outdir: outdirFlag, silthr, sildur, norm, verbose } = props;
+        // HACK ESM imports and geScrewed in oclif
+        const { DEBUG, ERROR } = { DEBUG: console.log, ERROR: (...Any) => new Error(JSON.stringify(Any)) }; //Logger.setup(verbose ? Logger.DEBUG : Logger.INFO) // eslint-disable-line no-unused-vars
+        DEBUG('Starting Prep with:', props);
+        return new Promise(async (resolveFx, rejectFx) => {
+            const silenceInfo = [];
+            const info = { traces: [], silenceInfo };
+            const sourceFileName = getNameWithExt(input);
+            const cachedRnnnPath = await _a.ensureRnnnIsCached(this.config);
+            // const isCreateInterimArtifacts = true // ? consider implement chaining if this is false and add param
+            const phase1input = input;
+            const phase1Name = getName(phase1input);
+            const outDir = `${outdirFlag}/${phase1Name}`;
+            fs.mkdirSync(path.normalize(outDir), { recursive: true });
+            const phase1OutputPath = `${outDir}/${phase1Name}-denoised.wav`;
+            const ffmpegChain = ffmpeg(phase1input, { logger: console });
+            ffmpegChain
+                .audioFilters([
+                {
+                    filter: 'arnndn',
+                    options: { m: cachedRnnnPath, mix: 1 } // mix:-1 means keep only noise https://ffmpeg.org/ffmpeg-filters.html#arnndn
+                },
+                {
+                    filter: 'silencedetect',
+                    options: { n: silthr, d: sildur }
+                },
+            ])
+                .audioFrequency(16000) // required for whisper
+                .outputOptions(['-ac 1', '-c:a pcm_s16le'])
+                .on('codecData', function (data) {
+                const codecInfo = 'Input is ' + data.audio + ' audio ' + 'with ' + data.video + ' video';
+                info.traces.push([codecInfo]);
+                DEBUG(codecInfo);
+            })
+                .on('stderr', function (stderrLine) {
+                if (stderrLine.includes(' silence_end: ')) {
+                    const endInfo = stderrLine.split(' silence_end: ')[1].split(' | silence_duration: ');
+                    const [endSec, duration] = endInfo.map(s => +s);
+                    silenceInfo.push({ stSec: endSec - duration, endSec, duration });
+                }
+            })
+                .on('error', function (error) {
+                rejectFx(ERROR('Error:', error, silthr));
+            })
+                .on('end', async function (stdout, stderr) {
+                const successTrace = ['Phase2 succeeded: ', { silenceInfo, phase2OutputPath: phase1OutputPath }];
+                info.traces.push(successTrace);
+                DEBUG(successTrace);
+                CliUx.ux.table(silenceInfo, { stSec: {}, endSec: {}, duration: {} });
+                const outputPath = norm ? await _a.normalize(phase1OutputPath, outDir) : phase1OutputPath;
+                const results = { ffmpegChain, outputPath };
+                resolveFx({ props, info, results });
+            })
+                .save(phase1OutputPath);
+        });
+    }
+    /**
+     * only for cli parsing
+     */
+    async run() {
+        const { args: { input }, flags, flags: { outdir, silthr, sildur, norm, verbose } } = await this.parse(_a);
+        const report = await this.doPrep({ input, outdir, silthr, sildur, norm, verbose });
+        verbose && console.log(report);
+    }
+}
+_a = Prep;
+Prep.description = 'Prepare audio file - normalize, noise reduce, split on silence';
+Prep.DEFAULTS = {
+    SILDUR: '1.3',
+    SILBUF: 0.2,
+    SILTHR: '-35dB',
+    RNNN: 'https://raw.githubusercontent.com/GregorR/rnnoise-models/master/somnolent-hogwash-2018-09-01/sh.rnnn'
+};
+Prep.args = [{ name: 'input', description: 'input file', required: true }];
+Prep.flags = {
+    norm: Flags.boolean({ char: 'n', description: 'do normalization?', required: false, default: false }),
+    verbose: Flags.boolean({ char: 'v', description: 'trace more?', required: false, default: false }),
+    outdir: Flags.string({ char: 'o', description: 'output directory', required: false, default: './out' }),
+    silthr: Flags.string({ char: 's', description: 'silence threshold', required: false, default: _a.DEFAULTS.SILTHR }),
+    sildur: Flags.string({ char: 'd', description: 'silence duration', required: false, default: _a.DEFAULTS.SILDUR }),
+};
+/**
+ * subroutines
+ */
+Prep.normalize = doNormalization;
+Prep.removeSilence = doSilenceRemoval;
+/**
+ * cli only (depends on config and fs situation)
+ */
+Prep.ensureRnnnIsCached = async (config) => {
+    const cachedRnnnPath = `${config.cacheDir}/sh.rnnn`;
+    const isRnnnExisting = fs.existsSync(cachedRnnnPath);
+    if (!isRnnnExisting) {
+        console.log(`
+      rnnn for noise removal missing
+      Fetching ${_a.DEFAULTS.RNNN} into ${cachedRnnnPath}
+    `);
+        const data = await fetch(_a.DEFAULTS.RNNN);
+        fs.writeFileSync(cachedRnnnPath, await data.text());
+    }
+    else
+        console.log(`Found ${cachedRnnnPath} \n`);
+    return cachedRnnnPath;
+};
+Prep.examples = [
+    `$ tranz prep AI_Could_Be_The_End_Of_Democracy.m4a' -s -35dB -d 1.5
+--> sets silence threshold to -35dB and min silence duration to 1.5s
+--> runs normalization and noise removal
+`,
+];
+export default Prep;

package/dist/commands/scribe/index.d.ts

@@ -0,0 +1,43 @@
+import { Command } from "@oclif/core";
+export default class Scribe extends Command {
+    static DEFAULTS: {
+        DIARIZE: boolean;
+        SILDUR: string;
+        SILBUF: number;
+        SILTHR: string;
+        MODEL_KEYS: {
+            tinyd: string;
+            small: string;
+            medium: string;
+        };
+        MODELS: {
+            tinyd: string;
+            small: string;
+            medium: string;
+        };
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        prep: import("@oclif/core/lib/interfaces/parser").BooleanFlag<boolean>;
+        withGPU: import("@oclif/core/lib/interfaces/parser").BooleanFlag<boolean>;
+        norm: import("@oclif/core/lib/interfaces/parser").BooleanFlag<boolean>;
+        output: import("@oclif/core/lib/interfaces/parser").OptionFlag<string>;
+        diarization: import("@oclif/core/lib/interfaces/parser").BooleanFlag<boolean>;
+        separate_speakers: import("@oclif/core/lib/interfaces/parser").BooleanFlag<boolean>;
+        provider: import("@oclif/core/lib/interfaces/parser").OptionFlag<string>;
+        model: import("@oclif/core/lib/interfaces/parser").OptionFlag<string | undefined>;
+        language: import("@oclif/core/lib/interfaces/parser").OptionFlag<string | undefined>;
+        timestamps: import("@oclif/core/lib/interfaces/parser").OptionFlag<string | undefined>;
+        "no-pauses": import("@oclif/core/lib/interfaces/parser").BooleanFlag<boolean>;
+        "auto-split": import("@oclif/core/lib/interfaces/parser").BooleanFlag<boolean>;
+        "max-segment": import("@oclif/core/lib/interfaces/parser").OptionFlag<number>;
+        "split-silence-dur": import("@oclif/core/lib/interfaces/parser").OptionFlag<string>;
+    };
+    static args: {
+        name: string;
+        description: string;
+        required: boolean;
+    }[];
+    run(): Promise<void>;
+}

package/dist/commands/scribe/index.js

@@ -0,0 +1,383 @@
+import { Command, Flags } from "@oclif/core";
+import * as fs from "node:fs";
+import path from "node:path";
+import { getName } from "../../utils/file-utils.js";
+import { loadSecretOrThrow } from "../../utils/secrets.js";
+import { formatBytes } from "../../utils/formatBytes.js";
+import Prep from "../prep/index.js";
+import { createProvider, VOXTRAL_LIMITS, formatTranscriptWithPauses, autoSplitAudio, getAudioDuration, mergeTranscriptionResults, } from "@wovin/tranz";
+class Scribe extends Command {
+    async run() {
+        const { args: { input }, flags, flags: { output: outputFlag, diarization, separate_speakers, prep, norm, provider: providerFlag, model, language, timestamps, withGPU, "no-pauses": noPauses, "auto-split": autoSplit, "max-segment": maxSegment, "split-silence-dur": splitSilenceDur, }, } = await this.parse(Scribe);
+        // Use new diarization flag, fallback to deprecated separate_speakers
+        const enableDiarization = diarization || separate_speakers;
+        let inputPath = input;
+        const sourceFileName = getName(inputPath);
+        // 🎙️ Header
+        this.log("\n🎙️  Transcribing Audio\n");
+        // 🎵 Loading audio file with size
+        const fileStats = fs.statSync(inputPath);
+        const fileSize = formatBytes(fileStats.size);
+        this.log(`🎵 Loading audio file: ${inputPath}`);
+        this.log(`   Size: ${fileSize}`);
+        if (prep) {
+            const prepCommand = new Prep([], this.config);
+            const prepResult = prepCommand.doPrep({
+                input: inputPath,
+                outdir: outputFlag,
+                norm,
+                verbose: true,
+                silthr: "35dB",
+                sildur: "1.2",
+            });
+            inputPath = (await prepResult).results.outputPath;
+        }
+        const outputDir = `${outputFlag}/${sourceFileName}`;
+        fs.mkdirSync(path.normalize(outputDir), { recursive: true });
+        // Normalize provider name (voxtral -> mistral)
+        let providerName = (providerFlag === "voxtral" ? "mistral" : providerFlag);
+        // Handle API-based providers
+        let apiKey;
+        if (providerName === "mistral" || providerName === "greenpt") {
+            if (withGPU) {
+                this.warn(`--withGPU flag is not applicable to ${providerName} provider (API-based)`);
+            }
+            if (providerName === "mistral") {
+                if (timestamps && language) {
+                    this.error(`--timestamps and --language cannot be used together (Mistral API limitation)\nSee: https://docs.mistral.ai/capabilities/audio_transcription`);
+                }
+            }
+            // Load API key
+            const envVarMap = {
+                mistral: { envVar: "MISTRAL_API_KEY", secretPath: "secret/mistral" },
+                greenpt: { envVar: "GREENPT_API_KEY", secretPath: "secret/greenpt" },
+            };
+            const { envVar, secretPath } = envVarMap[providerName];
+            apiKey = await loadSecretOrThrow(envVar, secretPath, `${providerName} API key`);
+        }
+        // ⚙️ Configuration summary
+        const actualModel = model || (providerName === "mistral" ? "voxtral-mini-latest" : providerName === "greenpt" ? "whisper-large-v3" : "medium");
+        this.log(`\n⚙️  Configuration:`);
+        this.log(`   Provider: ${providerName}`);
+        this.log(`   Model: ${actualModel}`);
+        if (language) {
+            this.log(`   Language: ${language}`);
+        }
+        if (timestamps) {
+            this.log(`   Timestamps: ${timestamps}`);
+        }
+        if (enableDiarization) {
+            this.log(`   Diarization: enabled`);
+        }
+        if (autoSplit) {
+            this.log(`   Auto-split: enabled (max ${maxSegment}s segments)`);
+        }
+        // Create provider
+        const provider = createProvider(providerName, this.config);
+        // Check if provider has limits that require auto-split
+        let effectiveAutoSplit = autoSplit;
+        let effectiveMaxSegment = maxSegment;
+        // For Mistral/Voxtral provider, auto-enable split if audio exceeds limit
+        if (providerName === "mistral") {
+            const audioDuration = await getAudioDuration(inputPath);
+            if (audioDuration > VOXTRAL_LIMITS.recommendedMaxDurationSec) {
+                if (!autoSplit) {
+                    this.log(`\n⚠️  Audio duration (${Math.floor(audioDuration / 60)}m) exceeds Voxtral limit (${VOXTRAL_LIMITS.recommendedMaxDurationSec / 60}m)`);
+                    this.log(`   Auto-enabling split mode...`);
+                    effectiveAutoSplit = true;
+                    effectiveMaxSegment = VOXTRAL_LIMITS.recommendedMaxDurationSec;
+                }
+            }
+        }
+        // Determine if we need to auto-split
+        let result;
+        let segments;
+        if (effectiveAutoSplit) {
+            // Get audio duration to check if splitting is needed
+            const audioDuration = await getAudioDuration(inputPath);
+            this.log(`\n📏 Audio duration: ${Math.floor(audioDuration / 60)}m ${(audioDuration % 60).toFixed(0)}s`);
+            if (audioDuration > effectiveMaxSegment) {
+                // Split audio at silence boundaries
+                this.log(`\n✂️  Splitting audio (exceeds ${effectiveMaxSegment}s max)...`);
+                const splitConfig = {
+                    maxDurationSec: effectiveMaxSegment,
+                    minSilenceDurSec: parseFloat(splitSilenceDur),
+                    preferLongerSilence: true,
+                };
+                const segmentsDir = path.join(outputDir, 'segments');
+                segments = await autoSplitAudio(inputPath, segmentsDir, splitConfig);
+                this.log(`   Created ${segments.length} segments`);
+                for (const seg of segments) {
+                    this.log(`   - Segment ${seg.index}: ${seg.startSec.toFixed(1)}s - ${seg.endSec.toFixed(1)}s (${seg.durationSec.toFixed(1)}s)`);
+                }
+                // Transcribe each segment
+                this.log(`\n⏳ Transcribing ${segments.length} segments...`);
+                const segmentResults = [];
+                for (const seg of segments) {
+                    this.log(`   Transcribing segment ${seg.index + 1}/${segments.length}...`);
+                    const segResult = await provider.transcribe({
+                        audioPath: seg.outputPath,
+                        outputDir,
+                        model,
+                        language,
+                        timestampGranularity: timestamps,
+                        diarize: enableDiarization,
+                        apiKey,
+                    });
+                    segmentResults.push(segResult);
+                    if (segResult.error) {
+                        this.warn(`   Segment ${seg.index} error: ${segResult.error}`);
+                    }
+                }
+                // Merge results
+                result = mergeTranscriptionResults(segmentResults, segments);
+                this.log(`\n🔗 Merged ${segments.length} segment transcriptions`);
+            }
+            else {
+                this.log(`\n⏳ Transcribing (no split needed)...`);
+                result = await provider.transcribe({
+                    audioPath: inputPath,
+                    outputDir,
+                    model,
+                    language,
+                    timestampGranularity: timestamps,
+                    diarize: enableDiarization,
+                    apiKey,
+                });
+            }
+        }
+        else {
+            // ⏳ Progress indicator
+            this.log(`\n⏳ Transcribing...`);
+            result = await provider.transcribe({
+                audioPath: inputPath,
+                outputDir,
+                model,
+                language,
+                timestampGranularity: timestamps,
+                diarize: enableDiarization,
+                apiKey,
+            });
+        }
+        if (result.error) {
+            throw new Error(`Transcription failed: ${result.error}`);
+        }
+        // Determine output filename based on provider
+        let outputFileName;
+        switch (providerName) {
+            case "mistral":
+                outputFileName = `${sourceFileName}-transcript-mistral.json`;
+                break;
+            case "greenpt":
+                outputFileName = `${sourceFileName}-transcript-greenpt.json`;
+                break;
+            case "whisper":
+            default:
+                outputFileName = `${sourceFileName}-transcript.json`;
+        }
+        const outputPath = `${outputDir}/${outputFileName}`;
+        // For Whisper, the file is already saved by the provider (unless we did auto-split)
+        // For API providers or auto-split, save the result
+        if (providerName !== "whisper" || segments) {
+            fs.writeFileSync(outputPath, JSON.stringify(result.rawResponse || result, null, 2));
+        }
+        // Show segment info if we split
+        const mergedResult = result;
+        if (mergedResult.totalSegments && mergedResult.totalSegments > 1) {
+            this.log(`\n📊 Split Summary:`);
+            this.log(`   Total segments: ${mergedResult.totalSegments}`);
+        }
+        // 📝 Transcript preview
+        this.log(`\n📝 Transcript preview:`);
+        let previewText = result.text;
+        // Apply pause formatting if words data available and not disabled
+        const words = result.rawResponse?.words || result.words;
+        if (!noPauses && words && words.length > 0) {
+            previewText = formatTranscriptWithPauses(result.text, words);
+        }
+        // Show first 200 chars of preview
+        const previewLimit = 200;
+        const truncatedPreview = previewText.length > previewLimit
+            ? previewText.substring(0, previewLimit) + "..."
+            : previewText;
+        this.log(`   ${truncatedPreview.replace(/\n/g, "\n   ")}`);
+        // 📊 Metadata summary
+        this.log(`\n📊 Metadata:`);
+        const duration = result.rawResponse?.duration || result.duration;
+        if (duration) {
+            const minutes = Math.floor(duration / 60);
+            const seconds = (duration % 60).toFixed(1);
+            this.log(`   Duration: ${minutes}m ${seconds}s (${duration.toFixed(1)}s)`);
+        }
+        // Show actual model if returned by API (may differ from requested)
+        if (result.model) {
+            this.log(`   Model (actual): ${result.model}`);
+        }
+        const wordCount = result.text.split(/\s+/).filter((w) => w.length > 0).length;
+        const charCount = result.text.length;
+        this.log(`   Words: ${wordCount}`);
+        this.log(`   Characters: ${charCount}`);
+        // 💰 Detailed cost breakdown
+        this.log(`\n💰 Cost:`);
+        if (duration) {
+            const durationMinutes = duration / 60;
+            this.log(`   Duration: ${durationMinutes.toFixed(2)} minutes`);
+            // Provider-specific cost rates
+            if (providerName === "mistral") {
+                // $0.003 per minute for Voxtral Transcribe 2
+                // Source: https://docs.mistral.ai/models/voxtral-mini-transcribe-26-02
+                const audioRate = 0.003;
+                const audioCost = durationMinutes * audioRate;
+                this.log(`   Rate: $${audioRate}/min`);
+                this.log(`   Audio cost: $${audioCost.toFixed(4)}`);
+                // Token cost if available
+                const usage = result.rawResponse?.usage;
+                if (usage?.total_tokens) {
+                    const tokenRate = 0.000003; // ~$3/1M tokens estimate for Mistral
+                    const tokenCost = usage.total_tokens * tokenRate;
+                    this.log(`   Token cost: $${tokenCost.toFixed(4)} (${usage.total_tokens} tokens)`);
+                    this.log(`   Total: $${(audioCost + tokenCost).toFixed(4)}`);
+                }
+                else {
+                    this.log(`   Total: $${audioCost.toFixed(4)}`);
+                }
+            }
+            else if (providerName === "greenpt") {
+                const audioRate = 0.006; // $0.006 per minute estimate
+                const audioCost = durationMinutes * audioRate;
+                this.log(`   Rate: $${audioRate}/min`);
+                this.log(`   Total: $${audioCost.toFixed(4)}`);
+            }
+            else {
+                this.log(`   Local whisper: no API cost`);
+            }
+        }
+        else {
+            this.log(`   Duration data not available for cost calculation`);
+        }
+        // 💾 Save notification
+        this.log(`\n💾 Saved to: ${outputPath}`);
+        this.log(`\n✅ Transcription completed successfully!\n`);
+    }
+}
+Scribe.DEFAULTS = {
+    DIARIZE: false,
+    SILDUR: "1.3",
+    SILBUF: 0.2,
+    SILTHR: "-35dB",
+    MODEL_KEYS: {
+        tinyd: "ggml-small.en-tdrz.bin",
+        small: "ggml-small.bin",
+        medium: "ggml-medium.bin",
+    },
+    MODELS: {
+        tinyd: "https://huggingface.co/akashmjn/tinydiarize-whisper.cpp/resolve/main/ggml-small.en-tdrz.bin",
+        small: "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-small.bin",
+        medium: "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-medium.bin",
+    },
+};
+Scribe.description = "Transcribe audio file - optionally prepare first";
+Scribe.examples = [
+    `$ tranz scribe 'path/to/16khz-audiofile.wav'
+runs whisper and outputs and saves a transcription json
+
+$ tranz scribe 'path/to/whatever-audiofile.mp3' -p
+first prepares and then runs whisper and outputs and saves a transcription json
+
+$ tranz scribe 'path/to/audiofile.mp3' -r mistral -m voxtral-mini-latest
+transcribe using Mistral provider with specified model
+
+$ tranz scribe 'path/to/audiofile.mp3' -r mistral --timestamps segment
+transcribe using Mistral with segment-level timestamps
+
+$ tranz scribe 'path/to/audiofile.mp3' -r mistral --diarization --timestamps word
+transcribe using Mistral with speaker diarization and word-level timestamps
+
+$ tranz scribe 'path/to/audiofile.mp3' -r greenpt -l en
+transcribe using GreenPT provider with language specification
+
+$ tranz scribe 'path/to/long-audio.mp3' --auto-split --max-segment 300
+automatically split long audio at silence boundaries (max 5 min segments)
+`,
+];
+Scribe.flags = {
+    prep: Flags.boolean({
+        char: "p",
+        description: "do prep?",
+        required: false,
+        default: false,
+    }),
+    withGPU: Flags.boolean({
+        char: "g",
+        description: "use gpu?",
+        required: false,
+        default: false,
+    }),
+    norm: Flags.boolean({
+        char: "n",
+        description: "do normalization?",
+        required: false,
+        default: false,
+    }),
+    output: Flags.string({
+        char: "o",
+        description: "output directory",
+        required: false,
+        default: "./out",
+    }),
+    diarization: Flags.boolean({
+        char: "d",
+        description: "enable speaker diarization",
+        required: false,
+        default: Scribe.DEFAULTS.DIARIZE,
+    }),
+    separate_speakers: Flags.boolean({
+        description: "separate via diarization (deprecated: use --diarization)",
+        required: false,
+        deprecated: {
+            message: "use --diarization instead",
+        },
+    }),
+    provider: Flags.string({
+        char: "r",
+        description: "transcription provider (whisper, mistral, greenpt)",
+        options: ["whisper", "mistral", "voxtral", "greenpt"],
+        default: "whisper",
+    }),
+    model: Flags.string({
+        char: "m",
+        description: "model name (provider-specific)",
+    }),
+    language: Flags.string({
+        char: "l",
+        description: "language code (e.g., en, de, fr)",
+    }),
+    timestamps: Flags.string({
+        description: "enable timestamp granularity (segment, word) - Mistral only",
+        options: ["segment", "word"],
+    }),
+    "no-pauses": Flags.boolean({
+        description: "disable pause-based line break formatting in transcript preview",
+        default: false,
+    }),
+    "auto-split": Flags.boolean({
+        description: "automatically split long audio files at silence boundaries",
+        default: false,
+    }),
+    "max-segment": Flags.integer({
+        description: "maximum segment duration in seconds for auto-split (default: 600)",
+        default: 600,
+    }),
+    "split-silence-dur": Flags.string({
+        description: "minimum silence duration for split points (default: 1.0)",
+        default: "1.0",
+    }),
+};
+Scribe.args = [
+    {
+        name: 'input',
+        description: 'input file',
+        required: true,
+    },
+];
+export default Scribe;

package/dist/commands/split/index.d.ts

@@ -0,0 +1,23 @@
+import { Command } from '@oclif/core';
+export default class Split extends Command {
+    static description: string;
+    static DEFAULTS: {
+        OUTDIR: string;
+        SILDUR: string;
+        SILBUF: number;
+        SILTHR: string;
+    };
+    static flags: {
+        output: import("@oclif/core/lib/interfaces/parser").OptionFlag<string>;
+        silthr: import("@oclif/core/lib/interfaces/parser").OptionFlag<string>;
+        sildur: import("@oclif/core/lib/interfaces/parser").OptionFlag<string>;
+    };
+    static args: {
+        name: string;
+        description: string;
+        required: boolean;
+    }[];
+    static split: () => void;
+    run(): Promise<void>;
+    static examples: string[];
+}