callkaro-cli-unofficial 0.1.0

package/dist/commands/voices.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.voicesCommand = voicesCommand;
+const session_1 = require("../lib/session");
+const ui_1 = require("../lib/ui");
+const slug = (value) => String(value).toLowerCase().replace(/[^a-z0-9]/g, '');
+/**
+ * CLI flag -> candidate provider filter names, in priority order. The provider
+ * catalogue declares which filters it actually accepts, so a flag maps to
+ * whichever name that provider uses (or is reported unsupported).
+ */
+const filterOptions = [
+    { option: 'model', names: ['model'] },
+    { option: 'language', names: ['language', 'locale', 'languages'] },
+    { option: 'locale', names: ['locale'] },
+    { option: 'gender', names: ['gender'] },
+    { option: 'query', names: ['query'] },
+    { option: 'voiceId', names: ['voiceId', 'id'] },
+    { option: 'voiceName', names: ['voiceName', 'voice_name'] },
+    { option: 'style', names: ['style'] },
+    { option: 'languages', names: ['languages'] },
+    { option: 'accent', names: ['accent'] },
+    { option: 'useCases', names: ['useCases'] },
+    { option: 'category', names: ['category'] },
+    { option: 'voiceType', names: ['voiceType'] },
+    { option: 'highQuality', names: ['highQuality'] },
+    { option: 'voiceIds', names: ['voiceIds'] },
+    { option: 'collectionId', names: ['collectionId'] },
+    { option: 'sort', names: ['sort'] },
+    { option: 'sortDirection', names: ['sortDirection'] },
+    { option: 'isOwner', names: ['isOwner'] },
+    { option: 'includeArchived', names: ['includeArchived'] },
+    { option: 'type', names: ['type'] },
+    { option: 'projectId', names: ['projectId'] },
+    { option: 'id', names: ['id'] },
+    { option: 'limit', names: ['limit'] },
+];
+function findProvider(providers, name) {
+    return providers.find((provider) => slug(provider.provider) === slug(name));
+}
+function providerLanguages(provider) {
+    const configured = (provider.modelConfigurations || []).flatMap((m) => m.languages || []);
+    const direct = (provider.languages || []).map((l) => (typeof l === 'string' ? l : l.value || ''));
+    return [...new Set([...configured, ...direct].filter(Boolean))];
+}
+function listProviders(providers, json) {
+    if (json)
+        return void console.log(JSON.stringify(providers, null, 2));
+    (0, ui_1.table)(['PROVIDER', 'MODELS', 'LANGUAGES', 'VOICES FROM'], providers.map((provider) => [
+        provider.provider,
+        (provider.models || []).join('\n') || '(none)',
+        providerLanguages(provider).join(' ') || 'voice catalogue',
+        provider.voiceSource?.type === 'endpoint' ? 'backend catalogue' : provider.voiceSource?.type || '',
+    ]));
+    (0, ui_1.info)(`\n${providers.length} provider(s). Use \`cku voices --provider <name> --fields\` for configuration fields.`);
+}
+function showFields(provider, json) {
+    const fields = Object.keys(provider.defaultConfiguration || {});
+    const details = {
+        provider: provider.provider,
+        fields,
+        models: provider.modelConfigurations,
+        defaults: provider.defaultConfiguration,
+        controls: provider.controls,
+        controlConfigurations: provider.controlConfigurations,
+        filters: provider.filters,
+    };
+    if (json)
+        return void console.log(JSON.stringify(details, null, 2));
+    (0, ui_1.keyValue)({
+        provider: provider.provider,
+        'voice_configuration keys': fields.join(', '),
+        models: (provider.models || []).join(', ') || '(no voice_model key)',
+        languages: providerLanguages(provider).join(' ') || '(from voice catalogue)',
+        'search filters': Object.keys(provider.filters || {}).join(', ') || '(none)',
+    });
+}
+/** Flatten a provider's varied voice response into one table row shape. */
+function normalizeVoices(provider, response) {
+    const defaultModel = String(provider.defaultConfiguration?.voice_model || '');
+    const defaultLanguage = String(provider.defaultConfiguration?.voice_language || '');
+    return (Array.isArray(response.voices) ? response.voices : []).map((voice) => ({
+        ...voice,
+        provider: provider.provider,
+        name: String(voice.DisplayName || voice.display_name || voice.name || voice.voice_name || voice.id || ''),
+        id: String(voice.ShortName || voice.voice_id || voice.id || voice.voice_name || ''),
+        model: String(voice.model || response.model || defaultModel),
+        language: String(voice.Locale || voice.locale || voice.sublanguage || voice.language || response.locale || defaultLanguage),
+        gender: String(voice.Gender || voice.labels?.gender || voice.gender || '').toLowerCase(),
+        extra: Array.isArray(voice.StyleList)
+            ? voice.StyleList.join(',')
+            : String(voice.description || voice.category || voice.style || ''),
+    }));
+}
+/** Validate one filter value against the provider's declared filter schema. */
+function normalizeFilterValue(name, value, definition) {
+    if (definition.type === 'integer') {
+        const parsed = Number(value);
+        if (!Number.isInteger(parsed) ||
+            (definition.min !== undefined && parsed < definition.min) ||
+            (definition.max !== undefined && parsed > definition.max)) {
+            throw new Error(`--${name} must be an integer between ${definition.min} and ${definition.max}.`);
+        }
+        return parsed;
+    }
+    if (definition.type === 'boolean')
+        return Boolean(value);
+    const normalized = String(value).trim();
+    if (!normalized)
+        throw new Error(`--${name} cannot be empty.`);
+    if (definition.type === 'string[]') {
+        const values = normalized.split(',').map((item) => item.trim()).filter(Boolean);
+        if (!values.length || (definition.maxItems !== undefined && values.length > definition.maxItems)) {
+            throw new Error(`--${name} must contain between 1 and ${definition.maxItems || 'more'} values.`);
+        }
+        return values.join(',');
+    }
+    if (definition.values && !definition.values.includes(normalized)) {
+        // Providers disagree on gender spelling; accept either and send the provider's.
+        const genderAliases = {
+            male: 'masculine', female: 'feminine', masculine: 'male', feminine: 'female',
+        };
+        const alias = genderAliases[normalized];
+        if (name === 'gender' && alias && definition.values.includes(alias))
+            return alias;
+        throw new Error(`--${name} must be one of: ${definition.values.join(', ')}.`);
+    }
+    return normalized;
+}
+/**
+ * Map CLI flags onto the filters this provider accepts. `strict` (a provider was
+ * named explicitly) turns a bad value into an error; otherwise the provider is
+ * just skipped as unsupported, so a cross-provider query still returns rows.
+ */
+function providerFilters(provider, opts, strict) {
+    const filters = {};
+    const unsupported = [];
+    for (const { option, names } of filterOptions) {
+        const value = opts[option];
+        if (value === undefined)
+            continue;
+        const filterName = names.find((name) => provider.filters?.[name]);
+        if (!filterName) {
+            unsupported.push(String(option));
+            continue;
+        }
+        try {
+            filters[filterName] = normalizeFilterValue(String(option), String(value), provider.filters[filterName]);
+        }
+        catch (error) {
+            if (strict)
+                throw error;
+            unsupported.push(String(option));
+        }
+    }
+    return { filters, unsupported };
+}
+function unknownProvider(name, providers) {
+    const available = providers.map((p) => p.provider).join(', ');
+    (0, ui_1.info)(`Voice provider "${name}" is not available.${available ? ` Available: ${available}.` : ''}`);
+    process.exitCode = 1;
+}
+async function voicesCommand(opts) {
+    try {
+        const api = (0, session_1.requireApi)();
+        const { providers } = await api.getVoiceCatalog();
+        const wanted = opts.provider ? findProvider(providers || [], opts.provider) : undefined;
+        if (opts.provider && !wanted)
+            return unknownProvider(opts.provider, providers || []);
+        const selected = wanted ? [wanted] : providers || [];
+        if (opts.providers)
+            return listProviders(selected, opts.json);
+        if (opts.fields) {
+            if (!wanted) {
+                (0, ui_1.info)('--fields needs a provider, e.g. `cku voices --provider cartesia --fields`.');
+                process.exitCode = 1;
+                return;
+            }
+            return showFields(wanted, opts.json);
+        }
+        const providerRequests = selected.map((provider) => ({
+            provider,
+            ...providerFilters(provider, opts, Boolean(wanted)),
+        }));
+        if (wanted && providerRequests[0].unsupported.length) {
+            (0, ui_1.info)(`${wanted.provider} does not support: ${providerRequests[0].unsupported.map((n) => `--${n}`).join(', ')}. ` +
+                'Use --fields to list its filters.');
+            process.exitCode = 1;
+            return;
+        }
+        const relevant = providerRequests.filter(({ unsupported }) => unsupported.length === 0);
+        // One provider failing must not lose the others' rows.
+        const results = await Promise.allSettled(relevant.map(async ({ provider, filters }) => {
+            const response = await api.getProviderVoices(provider.provider, filters);
+            return normalizeVoices(provider, response);
+        }));
+        const rows = results.flatMap((r) => (r.status === 'fulfilled' ? r.value : []));
+        if (opts.json)
+            return void console.log(JSON.stringify(rows, null, 2));
+        if (!rows.length)
+            return void (0, ui_1.info)('No voices matched. Try fewer filters, or `cku voices --providers`.');
+        (0, ui_1.table)(['PROVIDER', 'NAME', 'VOICE ID', 'MODEL', 'LANGUAGE', 'GENDER', 'NOTES'], rows.map((row) => [row.provider, row.name, row.id, row.model, row.language, row.gender, row.extra]));
+        (0, ui_1.info)(`\n${rows.length} voice(s).`);
+        const failed = relevant.filter((_, index) => results[index].status === 'rejected');
+        if (failed.length)
+            (0, ui_1.info)(`Note: some providers failed: ${failed.map(({ provider }) => provider.provider).join(', ')}`);
+    }
+    catch (err) {
+        (0, ui_1.handleError)(err);
+    }
+}