auralwise_cli 1.0.0

package/bin/auralwise.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { setLocale, t } from '../lib/i18n.js';
+import { registerTranscribe } from '../lib/commands/transcribe.js';
+import { registerTasks } from '../lib/commands/tasks.js';
+import { registerTask } from '../lib/commands/task.js';
+import { registerResult } from '../lib/commands/result.js';
+import { registerDelete } from '../lib/commands/delete.js';
+import { registerEvents } from '../lib/commands/events.js';
+
+const program = new Command();
+
+// Parse --locale early before command registration so descriptions use correct language
+const localeIdx = process.argv.indexOf('--locale');
+if (localeIdx !== -1 && process.argv[localeIdx + 1]) {
+  setLocale(process.argv[localeIdx + 1]);
+}
+
+program
+  .name('auralwise')
+  .description(t('descMain'))
+  .version('1.0.0')
+  .option('--api-key <key>', 'API key (or set AURALWISE_API_KEY env)')
+  .option('--base-url <url>', 'API base URL', 'https://auralwise.cn/api/v1')
+  .option('--locale <locale>', 'UI language: en or zh (default: en)');
+
+registerTranscribe(program);
+registerTasks(program);
+registerTask(program);
+registerResult(program);
+registerDelete(program);
+registerEvents(program);
+
+program.parse();

package/lib/client.js

@@ -0,0 +1,106 @@
+const DEFAULT_BASE_URL = 'https://auralwise.cn/api/v1';
+
+export class AuralWiseClient {
+  constructor({ apiKey, baseUrl } = {}) {
+    this.apiKey = apiKey;
+    this.baseUrl = (baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, '');
+  }
+
+  async _request(method, path, { body, query, headers: extraHeaders, timeout } = {}) {
+    let url = `${this.baseUrl}${path}`;
+    if (query) {
+      const params = new URLSearchParams();
+      for (const [k, v] of Object.entries(query)) {
+        if (v != null) params.set(k, String(v));
+      }
+      const qs = params.toString();
+      if (qs) url += `?${qs}`;
+    }
+
+    const headers = { 'X-API-Key': this.apiKey, ...extraHeaders };
+    const fetchOpts = { method, headers };
+
+    if (body !== undefined) {
+      if (typeof body === 'string' || body instanceof Buffer || body instanceof ArrayBuffer) {
+        fetchOpts.body = body;
+      } else {
+        headers['Content-Type'] = 'application/json';
+        fetchOpts.body = JSON.stringify(body);
+      }
+    }
+
+    if (timeout) {
+      fetchOpts.signal = AbortSignal.timeout(timeout);
+    }
+
+    const resp = await fetch(url, fetchOpts);
+    if (!resp.ok) {
+      let errMsg;
+      try {
+        const errBody = await resp.json();
+        errMsg = errBody.error || errBody.message || JSON.stringify(errBody);
+      } catch {
+        errMsg = await resp.text();
+      }
+      throw new Error(`API error ${resp.status}: ${errMsg}`);
+    }
+
+    if (resp.status === 204) return null;
+
+    const contentType = resp.headers.get('content-type') || '';
+    if (contentType.includes('application/json')) {
+      return resp.json();
+    }
+    return resp.text();
+  }
+
+  async createTask({ audioUrl, audioBase64, audioFilename, options, batchMode, priority, callbackUrl, callbackSecret }) {
+    const body = {};
+    if (audioUrl) {
+      body.audio_url = audioUrl;
+    } else if (audioBase64) {
+      body.audio_base64 = audioBase64;
+    }
+    if (audioFilename) body.audio_filename = audioFilename;
+    if (options) body.options = options;
+    if (batchMode) body.batch_mode = true;
+    if (priority != null) body.priority = priority;
+    if (callbackUrl) body.callback_url = callbackUrl;
+    if (callbackSecret) body.callback_secret = callbackSecret;
+
+    return this._request('POST', '/tasks', { body, timeout: 300000 });
+  }
+
+  async listTasks({ page, pageSize, status } = {}) {
+    return this._request('GET', '/tasks', {
+      query: { page, page_size: pageSize, status },
+    });
+  }
+
+  async getTask(taskId) {
+    return this._request('GET', `/tasks/${taskId}`);
+  }
+
+  async getResult(taskId) {
+    return this._request('GET', `/tasks/${taskId}/result`);
+  }
+
+  async deleteTask(taskId) {
+    return this._request('DELETE', `/tasks/${taskId}`);
+  }
+
+  async getAudioEventClasses() {
+    return this._request('GET', '/audio-event-classes');
+  }
+
+  async pollTask(taskId, { interval = 5000, onStatus } = {}) {
+    while (true) {
+      const task = await this.getTask(taskId);
+      if (onStatus) onStatus(task);
+      if (task.status === 'done' || task.status === 'failed' || task.status === 'abandoned') {
+        return task;
+      }
+      await new Promise(r => setTimeout(r, interval));
+    }
+  }
+}

package/lib/commands/delete.js

@@ -0,0 +1,34 @@
+import chalk from 'chalk';
+import { t } from '../i18n.js';
+import { createClient } from '../utils.js';
+
+export function registerDelete(program) {
+  program
+    .command('delete')
+    .description(t('descDelete'))
+    .argument('<id>', t('argTaskId'))
+    .option('--force', 'Skip confirmation')
+    .action(async (id, opts) => {
+      try {
+        if (!opts.force) {
+          const readline = await import('node:readline');
+          const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+          const answer = await new Promise(resolve => {
+            rl.question(t('confirmDelete', { id: id.substring(0, 8) }) + ' (y/N) ', resolve);
+          });
+          rl.close();
+          if (answer.toLowerCase() !== 'y') {
+            console.log(t('deleteCancelled'));
+            return;
+          }
+        }
+
+        const client = createClient(program);
+        await client.deleteTask(id);
+        console.log(chalk.green(t('taskDeleted', { id: id.substring(0, 8) })));
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+}

package/lib/commands/events.js

@@ -0,0 +1,58 @@
+import chalk from 'chalk';
+import { t, getLocale } from '../i18n.js';
+import { createClient } from '../utils.js';
+
+export function registerEvents(program) {
+  program
+    .command('events')
+    .description(t('descEvents'))
+    .option('--category <cat>', 'Filter by category')
+    .option('--search <keyword>', 'Search event name')
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+      try {
+        const client = createClient(program);
+        let classes = await client.getAudioEventClasses();
+
+        if (opts.category) {
+          const cat = opts.category.toLowerCase();
+          classes = classes.filter(c =>
+            (c.category || '').toLowerCase().includes(cat) ||
+            (c.category_zh || '').toLowerCase().includes(cat)
+          );
+        }
+
+        if (opts.search) {
+          const kw = opts.search.toLowerCase();
+          classes = classes.filter(c =>
+            (c.display_name || '').toLowerCase().includes(kw) ||
+            (c.zh_name || '').toLowerCase().includes(kw)
+          );
+        }
+
+        if (opts.json) {
+          console.log(JSON.stringify(classes, null, 2));
+          return;
+        }
+
+        if (classes.length === 0) {
+          console.log(t('noEventsFound'));
+          return;
+        }
+
+        const isZh = getLocale() === 'zh';
+        console.log(chalk.bold(`${t('totalClasses')}: ${classes.length}`));
+        console.log();
+        console.log(chalk.bold('Index  Name                                    Category'));
+        console.log('─'.repeat(80));
+        for (const c of classes) {
+          const name = isZh ? (c.zh_name || c.display_name) : c.display_name;
+          const cat = isZh ? (c.category_zh || c.category) : c.category;
+          console.log(`${String(c.index).padStart(5)}  ${name.padEnd(40)}  ${cat}`);
+        }
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+}

package/lib/commands/result.js

@@ -0,0 +1,31 @@
+import { writeFile } from 'node:fs/promises';
+import chalk from 'chalk';
+import { t } from '../i18n.js';
+import { createClient, printResult } from '../utils.js';
+
+export function registerResult(program) {
+  program
+    .command('result')
+    .description(t('descResult'))
+    .argument('<id>', t('argTaskId'))
+    .option('--json', 'Output as JSON')
+    .option('--output <file>', 'Save result to file')
+    .action(async (id, opts) => {
+      try {
+        const client = createClient(program);
+        const result = await client.getResult(id);
+
+        if (opts.output) {
+          await writeFile(opts.output, JSON.stringify(result, null, 2));
+          console.log(chalk.green(t('resultSaved', { file: opts.output })));
+        } else if (opts.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          printResult(result);
+        }
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+}

package/lib/commands/task.js

@@ -0,0 +1,26 @@
+import chalk from 'chalk';
+import { t } from '../i18n.js';
+import { createClient, printTaskDetail } from '../utils.js';
+
+export function registerTask(program) {
+  program
+    .command('task')
+    .description(t('descTask'))
+    .argument('<id>', t('argTaskId'))
+    .option('--json', 'Output as JSON')
+    .action(async (id, opts) => {
+      try {
+        const client = createClient(program);
+        const task = await client.getTask(id);
+
+        if (opts.json) {
+          console.log(JSON.stringify(task, null, 2));
+        } else {
+          printTaskDetail(task);
+        }
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+}

package/lib/commands/tasks.js

@@ -0,0 +1,45 @@
+import chalk from 'chalk';
+import { t } from '../i18n.js';
+import { createClient, formatTaskRow } from '../utils.js';
+
+export function registerTasks(program) {
+  program
+    .command('tasks')
+    .description(t('descTasks'))
+    .option('--status <status>', 'Filter by status (pending/processing/done/failed/abandoned)')
+    .option('--page <n>', 'Page number', parseInt, 1)
+    .option('--page-size <n>', 'Items per page', parseInt, 20)
+    .option('--json', 'Output as JSON')
+    .action(async (opts) => {
+      try {
+        const client = createClient(program);
+        const data = await client.listTasks({
+          page: opts.page,
+          pageSize: opts.pageSize,
+          status: opts.status,
+        });
+
+        if (opts.json) {
+          console.log(JSON.stringify(data, null, 2));
+          return;
+        }
+
+        const tasks = data.tasks || [];
+        if (tasks.length === 0) {
+          console.log(t('noTasks'));
+          return;
+        }
+
+        console.log(chalk.bold('ID        Status               Filename                                  Created'));
+        console.log('─'.repeat(100));
+        for (const task of tasks) {
+          console.log(formatTaskRow(task));
+        }
+        console.log('─'.repeat(100));
+        console.log(`${t('total')}: ${data.total || tasks.length}  ${t('page')}: ${data.page || 1}/${Math.ceil((data.total || tasks.length) / (data.page_size || 20))}`);
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+}

package/lib/commands/transcribe.js

@@ -0,0 +1,124 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { basename } from 'node:path';
+import chalk from 'chalk';
+import ora from 'ora';
+import { t } from '../i18n.js';
+import { createClient, printResult, formatStatus } from '../utils.js';
+
+export function registerTranscribe(program) {
+  program
+    .command('transcribe')
+    .description(t('descTranscribe'))
+    .argument('<source>', t('argSource'))
+    .option('--base64', 'Force base64 mode for local file upload')
+    .option('--language <lang>', 'ASR language (zh/en/ja/... or null for auto)')
+    .option('--no-asr', 'Disable ASR')
+    .option('--no-diarize', 'Disable speaker diarization')
+    .option('--no-events', 'Disable audio event detection')
+    .option('--optimize-zh', 'Enable Chinese optimization mode')
+    .option('--beam-size <n>', 'Beam search width', parseInt)
+    .option('--temperature <n>', 'Decoding temperature', parseFloat)
+    .option('--hotwords <words>', 'Hotwords (comma-separated)')
+    .option('--initial-prompt <text>', 'Initial prompt text')
+    .option('--vad-threshold <n>', 'VAD threshold (0-1)', parseFloat)
+    .option('--vad-min-speech <ms>', 'Min speech duration in ms', parseInt)
+    .option('--vad-min-silence <ms>', 'Min silence duration in ms', parseInt)
+    .option('--no-speech-threshold <n>', 'No-speech probability threshold', parseFloat)
+    .option('--num-speakers <n>', 'Fixed number of speakers', parseInt)
+    .option('--min-speakers <n>', 'Minimum speakers for auto-detection', parseInt)
+    .option('--max-speakers <n>', 'Maximum speakers for auto-detection', parseInt)
+    .option('--events-threshold <n>', 'Audio event confidence threshold', parseFloat)
+    .option('--events-classes <classes>', 'Specific event classes (comma-separated)')
+    .option('--batch', 'Enable batch mode (lower priority)')
+    .option('--callback-url <url>', 'Webhook callback URL')
+    .option('--callback-secret <secret>', 'Webhook HMAC secret')
+    .option('--no-wait', 'Submit and return immediately without polling')
+    .option('--poll-interval <seconds>', 'Polling interval in seconds', parseFloat, 5)
+    .option('--json', 'Output as JSON')
+    .option('--output <file>', 'Save result to file')
+    .action(async (source, opts) => {
+      try {
+        const client = createClient(program);
+        const isUrl = /^https?:\/\//i.test(source);
+
+        // Build options
+        const options = {};
+        if (opts.asr === false) options.enable_asr = false;
+        if (opts.diarize === false) options.enable_diarize = false;
+        if (opts.events === false) options.enable_audio_events = false;
+        if (opts.optimizeZh) options.optimize_zh = true;
+        if (opts.language) options.asr_language = opts.language;
+        if (opts.beamSize != null) options.asr_beam_size = opts.beamSize;
+        if (opts.temperature != null) options.asr_temperature = opts.temperature;
+        if (opts.hotwords) options.hotwords = opts.hotwords.split(',').map(s => s.trim());
+        if (opts.initialPrompt) options.initial_prompt = opts.initialPrompt;
+        if (opts.vadThreshold != null) options.vad_threshold = opts.vadThreshold;
+        if (opts.vadMinSpeech != null) options.vad_min_speech_ms = opts.vadMinSpeech;
+        if (opts.vadMinSilence != null) options.vad_min_silence_ms = opts.vadMinSilence;
+        if (opts.noSpeechThreshold != null) options.no_speech_threshold = opts.noSpeechThreshold;
+        if (opts.numSpeakers != null) options.num_speakers = opts.numSpeakers;
+        if (opts.minSpeakers != null) options.min_speakers = opts.minSpeakers;
+        if (opts.maxSpeakers != null) options.max_speakers = opts.maxSpeakers;
+        if (opts.eventsThreshold != null) options.audio_events_threshold = opts.eventsThreshold;
+        if (opts.eventsClasses) options.audio_events_classes = opts.eventsClasses.split(',').map(s => s.trim());
+
+        const taskParams = {
+          options: Object.keys(options).length > 0 ? options : undefined,
+          batchMode: opts.batch || false,
+          callbackUrl: opts.callbackUrl,
+          callbackSecret: opts.callbackSecret,
+        };
+
+        if (isUrl) {
+          taskParams.audioUrl = source;
+        } else {
+          const fileData = await readFile(source);
+          taskParams.audioBase64 = fileData.toString('base64');
+          taskParams.audioFilename = basename(source);
+        }
+
+        const spinner = ora(t('submittingTask')).start();
+        const task = await client.createTask(taskParams);
+        spinner.succeed(`${t('taskCreated')}: ${task.id}`);
+
+        if (opts.wait === false) {
+          if (opts.json) {
+            console.log(JSON.stringify(task, null, 2));
+          } else {
+            console.log(chalk.bold(`${t('status')}:`), formatStatus(task.status));
+          }
+          return;
+        }
+
+        const pollSpinner = ora(t('waitingTask')).start();
+        const completed = await client.pollTask(task.id, {
+          interval: (opts.pollInterval || 5) * 1000,
+          onStatus: (tsk) => {
+            const stage = tsk.current_stage ? ` (${tsk.current_stage})` : '';
+            const progress = tsk.progress != null ? ` ${tsk.progress}%` : '';
+            pollSpinner.text = `${tsk.status}${stage}${progress}`;
+          },
+        });
+
+        if (completed.status === 'done') {
+          pollSpinner.succeed(t('taskCompleted'));
+          const result = await client.getResult(task.id);
+
+          if (opts.output) {
+            await writeFile(opts.output, JSON.stringify(result, null, 2));
+            console.log(chalk.green(t('resultSaved', { file: opts.output })));
+          } else if (opts.json) {
+            console.log(JSON.stringify(result, null, 2));
+          } else {
+            printResult(result);
+          }
+        } else {
+          pollSpinner.fail(t('taskFailed', { status: completed.status, error: completed.error_message || 'unknown' }));
+          process.exit(1);
+        }
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+}

package/lib/i18n.js

@@ -0,0 +1,124 @@
+const messages = {
+  en: {
+    // General
+    apiKeyRequired: 'Error: API key required. Use --api-key or set AURALWISE_API_KEY environment variable.',
+    // Transcribe
+    submittingTask: 'Submitting task...',
+    taskCreated: 'Task created',
+    waitingTask: 'Waiting for task to complete...',
+    taskCompleted: 'Task completed!',
+    taskFailed: 'Task {status}: {error}',
+    resultSaved: 'Result saved to {file}',
+    // Result display
+    audioDuration: 'Audio Duration',
+    language: 'Language',
+    speakers: 'Speakers',
+    transcription: 'Transcription',
+    audioEvents: 'Audio Events',
+    speakerEmbeddings: 'Speaker Embeddings',
+    segments: 'segments',
+    dimVector: '-dim vector',
+    // Task detail
+    taskId: 'Task ID',
+    status: 'Status',
+    source: 'Source',
+    filename: 'Filename',
+    size: 'Size',
+    created: 'Created',
+    started: 'Started',
+    finished: 'Finished',
+    stage: 'Stage',
+    progress: 'Progress',
+    error: 'Error',
+    options: 'Options',
+    // Tasks list
+    noTasks: 'No tasks found.',
+    total: 'Total',
+    page: 'Page',
+    // Delete
+    taskDeleted: 'Task {id} deleted.',
+    confirmDelete: 'Are you sure you want to delete task {id}?',
+    deleteCancelled: 'Delete cancelled.',
+    // Events
+    totalClasses: 'Total event classes',
+    category: 'Category',
+    noEventsFound: 'No matching events found.',
+    // Descriptions
+    descMain: 'CLI for AuralWise audio intelligence API',
+    descTranscribe: 'Submit an audio transcription task (URL or local file)',
+    descTasks: 'List tasks',
+    descTask: 'Get task details',
+    descResult: 'Get task result',
+    descDelete: 'Delete a task',
+    descEvents: 'List audio event classes (521 classes)',
+    argSource: 'Audio URL or local file path',
+    argTaskId: 'Task ID',
+  },
+  zh: {
+    apiKeyRequired: '错误：需要 API Key。请使用 --api-key 参数或设置 AURALWISE_API_KEY 环境变量。',
+    submittingTask: '提交任务中...',
+    taskCreated: '任务已创建',
+    waitingTask: '等待任务完成...',
+    taskCompleted: '任务完成！',
+    taskFailed: '任务{status}：{error}',
+    resultSaved: '结果已保存到 {file}',
+    audioDuration: '音频时长',
+    language: '语言',
+    speakers: '说话人数',
+    transcription: '转写结果',
+    audioEvents: '声音事件',
+    speakerEmbeddings: '声纹向量',
+    segments: '段',
+    dimVector: '维向量',
+    taskId: '任务 ID',
+    status: '状态',
+    source: '来源',
+    filename: '文件名',
+    size: '大小',
+    created: '创建时间',
+    started: '开始时间',
+    finished: '完成时间',
+    stage: '阶段',
+    progress: '进度',
+    error: '错误',
+    options: '选项',
+    noTasks: '没有找到任务。',
+    total: '总计',
+    page: '页',
+    taskDeleted: '任务 {id} 已删除。',
+    confirmDelete: '确定要删除任务 {id} 吗？',
+    deleteCancelled: '已取消删除。',
+    totalClasses: '事件类别总数',
+    category: '类别',
+    noEventsFound: '未找到匹配的事件。',
+    descMain: 'AuralWise 语音智能 API 命令行工具',
+    descTranscribe: '提交音频转写任务（URL 或本地文件）',
+    descTasks: '列出任务',
+    descTask: '查看任务详情',
+    descResult: '获取任务结果',
+    descDelete: '删除任务',
+    descEvents: '列出声音事件类别（521 类）',
+    argSource: '音频 URL 或本地文件路径',
+    argTaskId: '任务 ID',
+  },
+};
+
+let currentLocale = 'en';
+
+export function setLocale(locale) {
+  currentLocale = (locale === 'zh' || locale === 'cn') ? 'zh' : 'en';
+}
+
+export function getLocale() {
+  return currentLocale;
+}
+
+export function t(key, params) {
+  let msg = messages[currentLocale]?.[key] || messages.en[key] || key;
+  if (params) {
+    for (const [k, v] of Object.entries(params)) {
+      msg = msg.replace(`{${k}}`, v);
+    }
+  }
+  return msg;
+}

package/lib/utils.js

@@ -0,0 +1,130 @@
+import chalk from 'chalk';
+import { t } from './i18n.js';
+import { AuralWiseClient } from './client.js';
+
+export function formatTime(seconds) {
+  const h = Math.floor(seconds / 3600);
+  const m = Math.floor((seconds % 3600) / 60);
+  const s = (seconds % 60).toFixed(1);
+  if (h > 0) return `${h}:${String(m).padStart(2, '0')}:${s.padStart(4, '0')}`;
+  return `${m}:${s.padStart(4, '0')}`;
+}
+
+export function formatDuration(seconds) {
+  if (seconds < 60) return `${seconds.toFixed(1)}s`;
+  if (seconds < 3600) return `${(seconds / 60).toFixed(1)}min`;
+  return `${(seconds / 3600).toFixed(1)}h`;
+}
+
+export function formatFileSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+export function formatStatus(status) {
+  const map = {
+    pending: chalk.yellow('pending'),
+    preprocessing: chalk.cyan('preprocessing'),
+    processing: chalk.blue('processing'),
+    proofreading: chalk.magenta('proofreading'),
+    done: chalk.green('done'),
+    failed: chalk.red('failed'),
+    abandoned: chalk.gray('abandoned'),
+  };
+  return map[status] || status;
+}
+
+export function formatTaskRow(task) {
+  const id = task.id.substring(0, 8);
+  const status = formatStatus(task.status);
+  const filename = (task.audio_filename || '-').substring(0, 38);
+  const created = new Date(task.created_at).toLocaleString();
+  return `${id}  ${status.padEnd(20)}  ${filename.padEnd(40)}  ${created}`;
+}
+
+export function printResult(result) {
+  if (result.audio_duration != null) {
+    console.log(chalk.bold(`${t('audioDuration')}:`), formatDuration(result.audio_duration));
+  }
+  if (result.language) {
+    const prob = result.language_probability != null ? ` (${(result.language_probability * 100).toFixed(0)}%)` : '';
+    console.log(chalk.bold(`${t('language')}:`), result.language + prob);
+  }
+  if (result.num_speakers != null) {
+    console.log(chalk.bold(`${t('speakers')}:`), result.num_speakers);
+  }
+
+  if (result.segments && result.segments.length > 0) {
+    console.log();
+    console.log(chalk.bold.underline(t('transcription')));
+    console.log();
+    for (const seg of result.segments) {
+      const time = `[${formatTime(seg.start)} - ${formatTime(seg.end)}]`;
+      const speaker = seg.speaker ? chalk.cyan(`${seg.speaker}: `) : '';
+      console.log(`${chalk.gray(time)} ${speaker}${seg.text}`);
+    }
+  }
+
+  if (result.audio_events && result.audio_events.length > 0) {
+    console.log();
+    console.log(chalk.bold.underline(t('audioEvents')));
+    console.log();
+    for (const ev of result.audio_events) {
+      const time = `[${formatTime(ev.start)} - ${formatTime(ev.end)}]`;
+      const conf = `${(ev.confidence * 100).toFixed(0)}%`;
+      console.log(`${chalk.gray(time)} ${ev.class} ${chalk.dim(`(${conf})`)}`);
+    }
+  }
+
+  if (result.speaker_embeddings && result.speaker_embeddings.length > 0) {
+    console.log();
+    console.log(chalk.bold.underline(t('speakerEmbeddings')));
+    console.log();
+    for (const spk of result.speaker_embeddings) {
+      console.log(`  ${chalk.cyan(spk.speaker_id)}: ${spk.segment_count} ${t('segments')}, ${spk.embedding.length}${t('dimVector')}`);
+    }
+  }
+}
+
+export function printTaskDetail(task) {
+  console.log(chalk.bold(`${t('taskId')}:`), task.id);
+  console.log(chalk.bold(`${t('status')}:`), formatStatus(task.status));
+  console.log(chalk.bold(`${t('source')}:`), task.audio_source_type || '-');
+  console.log(chalk.bold(`${t('filename')}:`), task.audio_filename || '-');
+  if (task.audio_size) console.log(chalk.bold(`${t('size')}:`), formatFileSize(task.audio_size));
+  console.log(chalk.bold(`${t('created')}:`), new Date(task.created_at).toLocaleString());
+  if (task.started_at) console.log(chalk.bold(`${t('started')}:`), new Date(task.started_at).toLocaleString());
+  if (task.finished_at) console.log(chalk.bold(`${t('finished')}:`), new Date(task.finished_at).toLocaleString());
+  if (task.current_stage) console.log(chalk.bold(`${t('stage')}:`), task.current_stage);
+  if (task.progress != null) console.log(chalk.bold(`${t('progress')}:`), `${task.progress}%`);
+  if (task.error_message) console.log(chalk.bold.red(`${t('error')}:`), task.error_message);
+
+  if (task.options) {
+    console.log(chalk.bold(`${t('options')}:`));
+    const opts = task.options;
+    const lines = [];
+    if (opts.enable_asr != null) lines.push(`  ASR: ${opts.enable_asr}`);
+    if (opts.enable_diarize != null) lines.push(`  Diarize: ${opts.enable_diarize}`);
+    if (opts.enable_audio_events != null) lines.push(`  Audio Events: ${opts.enable_audio_events}`);
+    if (opts.asr_language) lines.push(`  Language: ${opts.asr_language}`);
+    if (opts.optimize_zh) lines.push(`  Optimize ZH: ${opts.optimize_zh}`);
+    if (lines.length > 0) console.log(lines.join('\n'));
+  }
+}
+
+export function resolveApiKey(cmdOpts) {
+  const key = cmdOpts?.apiKey || process.env.AURALWISE_API_KEY;
+  if (!key) {
+    console.error(chalk.red(t('apiKeyRequired')));
+    process.exit(1);
+  }
+  return key;
+}
+
+export function createClient(program) {
+  const opts = program.opts();
+  const apiKey = resolveApiKey(opts);
+  const baseUrl = opts.baseUrl;
+  return new AuralWiseClient({ apiKey, baseUrl });
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "auralwise_cli",
+  "version": "1.0.0",
+  "description": "CLI for AuralWise audio intelligence API - transcription, speaker diarization, audio event detection",
+  "type": "module",
+  "bin": {
+    "auralwise": "./bin/auralwise.js"
+  },
+  "files": [
+    "bin/",
+    "lib/"
+  ],
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "keywords": [
+    "asr",
+    "speech-to-text",
+    "transcription",
+    "speaker-diarization",
+    "audio-events",
+    "auralwise",
+    "cli",
+    "audio",
+    "voice"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/wavpub/auralwise_cli"
+  },
+  "homepage": "https://auralwise.cn",
+  "author": "WavPub",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "ora": "^8.1.0"
+  },
+  "devDependencies": {
+    "vitest": "^2.1.0"
+  }
+}