meetscribe 1.0.0

package/src/cli/commands/protocol.js

@@ -0,0 +1,182 @@
+/**
+ * Protocol command - get meeting protocol
+ */
+
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+
+import { getApiKey, getApiUrl } from '../utils/config.js';
+import { MeetScribeClient } from '../../sdk/client.js';
+import { success, error, json } from '../utils/output.js';
+
+/**
+ * Format protocol to markdown
+ */
+function formatMarkdown(protocol) {
+  const lines = [];
+
+  lines.push(`# Meeting Protocol`);
+  lines.push('');
+
+  if (protocol.summary) {
+    lines.push('## Summary');
+    lines.push('');
+    lines.push(protocol.summary);
+    lines.push('');
+  }
+
+  if (protocol.participants_list && protocol.participants_list.length > 0) {
+    lines.push('## Participants');
+    lines.push('');
+    protocol.participants_list.forEach(p => {
+      const role = p.role ? ` (${p.role})` : '';
+      lines.push(`- ${p.name}${role}`);
+    });
+    lines.push('');
+  }
+
+  if (protocol.key_points && protocol.key_points.length > 0) {
+    lines.push('## Key Points');
+    lines.push('');
+    protocol.key_points.forEach(point => {
+      lines.push(`- ${point}`);
+    });
+    lines.push('');
+  }
+
+  if (protocol.decisions && protocol.decisions.length > 0) {
+    lines.push('## Decisions');
+    lines.push('');
+    protocol.decisions.forEach(decision => {
+      lines.push(`- ${decision}`);
+    });
+    lines.push('');
+  }
+
+  if (protocol.action_items && protocol.action_items.length > 0) {
+    lines.push('## Action Items');
+    lines.push('');
+    protocol.action_items.forEach(task => {
+      const assignee = task.assignee ? ` — ${task.assignee}` : '';
+      const deadline = task.deadline ? `, ${task.deadline}` : '';
+      const status = task.status === 'done' ? '[x]' : '[ ]';
+      lines.push(`- ${status} ${task.text}${assignee}${deadline}`);
+    });
+    lines.push('');
+  }
+
+  if (protocol.open_questions && protocol.open_questions.length > 0) {
+    lines.push('## Open Questions');
+    lines.push('');
+    protocol.open_questions.forEach(q => {
+      lines.push(`- ${q}`);
+    });
+    lines.push('');
+  }
+
+  if (protocol.next_meeting) {
+    lines.push('## Next Meeting');
+    lines.push('');
+    lines.push(protocol.next_meeting);
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Format protocol to plain text
+ */
+function formatText(protocol) {
+  const lines = [];
+
+  lines.push('MEETING PROTOCOL');
+  lines.push('================');
+  lines.push('');
+
+  if (protocol.summary) {
+    lines.push('SUMMARY:');
+    lines.push(protocol.summary);
+    lines.push('');
+  }
+
+  if (protocol.action_items && protocol.action_items.length > 0) {
+    lines.push('ACTION ITEMS:');
+    protocol.action_items.forEach((task, i) => {
+      const assignee = task.assignee ? ` [${task.assignee}]` : '';
+      const deadline = task.deadline ? ` (${task.deadline})` : '';
+      lines.push(`${i + 1}. ${task.text}${assignee}${deadline}`);
+    });
+    lines.push('');
+  }
+
+  if (protocol.key_points && protocol.key_points.length > 0) {
+    lines.push('KEY POINTS:');
+    protocol.key_points.forEach((point, i) => {
+      lines.push(`${i + 1}. ${point}`);
+    });
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Format output based on format option
+ */
+function formatOutput(protocol, format) {
+  switch (format) {
+    case 'markdown':
+    case 'md':
+      return formatMarkdown(protocol);
+
+    case 'txt':
+    case 'text':
+      return formatText(protocol);
+
+    case 'json':
+    default:
+      return JSON.stringify(protocol, null, 2);
+  }
+}
+
+export async function protocolCommand(materialId, options, command) {
+  // Check auth
+  const apiKey = command?.parent?.opts()?.apiKey || getApiKey();
+  if (!apiKey) {
+    error('Not authenticated. Run `meetscribe login` first.');
+    process.exit(1);
+  }
+
+  const client = new MeetScribeClient({
+    apiKey,
+    baseUrl: command?.parent?.opts()?.apiUrl || getApiUrl()
+  });
+
+  const spinner = ora('Fetching protocol...').start();
+
+  try {
+    const result = await client.getProtocol(materialId);
+    spinner.stop();
+
+    const protocol = result.data || result;
+    const output = formatOutput(protocol, options.format);
+
+    if (options.output) {
+      const outputPath = path.resolve(options.output);
+      fs.writeFileSync(outputPath, output);
+      console.log();
+      success(`Protocol saved to: ${outputPath}`);
+    } else {
+      console.log();
+      console.log(output);
+    }
+
+  } catch (err) {
+    spinner.fail('Failed to fetch protocol');
+    error(err.message);
+    process.exit(1);
+  }
+}

package/src/cli/commands/status.js

@@ -0,0 +1,62 @@
+/**
+ * Status command - check job status
+ */
+
+import chalk from 'chalk';
+import ora from 'ora';
+
+import { getApiKey, getApiUrl } from '../utils/config.js';
+import { MeetScribeClient } from '../../sdk/client.js';
+import { error, json, statusBadge, formatDuration } from '../utils/output.js';
+
+export async function statusCommand(jobId, options, command) {
+  // Check auth
+  const apiKey = command?.parent?.opts()?.apiKey || getApiKey();
+  if (!apiKey) {
+    error('Not authenticated. Run `meetscribe login` first.');
+    process.exit(1);
+  }
+
+  const client = new MeetScribeClient({
+    apiKey,
+    baseUrl: command?.parent?.opts()?.apiUrl || getApiUrl()
+  });
+
+  const spinner = ora('Fetching status...').start();
+
+  try {
+    const result = await client.getJobStatus(jobId);
+    spinner.stop();
+
+    const data = result.data || result;
+
+    console.log();
+    console.log(chalk.bold('Job Status'));
+    console.log();
+    console.log(`  ID:      ${chalk.cyan(jobId)}`);
+    console.log(`  Status:  ${statusBadge(data.status)}`);
+
+    if (data.progress !== undefined) {
+      console.log(`  Progress: ${data.progress}%`);
+    }
+
+    if (data.status_details) {
+      console.log(`  Details: ${data.status_details}`);
+    }
+
+    if (data.duration) {
+      console.log(`  Duration: ${formatDuration(data.duration)}`);
+    }
+
+    if (data.error) {
+      console.log(`  Error:   ${chalk.red(data.error)}`);
+    }
+
+    console.log();
+
+  } catch (err) {
+    spinner.fail('Failed to fetch status');
+    error(err.message);
+    process.exit(1);
+  }
+}

package/src/cli/commands/transcribe.js

@@ -0,0 +1,231 @@
+/**
+ * Transcribe command - upload and transcribe audio/video files
+ */
+
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+
+import { getApiKey, getApiUrl } from '../utils/config.js';
+import { MeetScribeClient } from '../../sdk/client.js';
+import { success, error, info, json, formatDuration } from '../utils/output.js';
+
+/**
+ * Format transcript to different output formats
+ */
+function formatOutput(result, format) {
+  const data = result.data || result;
+
+  switch (format) {
+    case 'json':
+      return JSON.stringify(data, null, 2);
+
+    case 'txt':
+      return data.transcript || data.transcription || data.text || '';
+
+    case 'srt':
+      return formatSrt(data.segments || []);
+
+    case 'vtt':
+      return formatVtt(data.segments || []);
+
+    default:
+      return JSON.stringify(data, null, 2);
+  }
+}
+
+/**
+ * Format to SRT subtitle format
+ */
+function formatSrt(segments) {
+  if (!segments || segments.length === 0) {
+    return '1\n00:00:00,000 --> 00:00:01,000\n(No segments available)\n';
+  }
+
+  return segments.map((seg, i) => {
+    const start = formatTimeSrt(seg.start || seg.start_time || 0);
+    const end = formatTimeSrt(seg.end || seg.end_time || 0);
+    const text = seg.text || seg.content || '';
+
+    return `${i + 1}\n${start} --> ${end}\n${text}\n`;
+  }).join('\n');
+}
+
+/**
+ * Format to VTT subtitle format
+ */
+function formatVtt(segments) {
+  if (!segments || segments.length === 0) {
+    return 'WEBVTT\n\n00:00:00.000 --> 00:00:01.000\n(No segments available)\n';
+  }
+
+  const lines = ['WEBVTT', ''];
+
+  segments.forEach((seg) => {
+    const start = formatTimeVtt(seg.start || seg.start_time || 0);
+    const end = formatTimeVtt(seg.end || seg.end_time || 0);
+    const text = seg.text || seg.content || '';
+
+    lines.push(`${start} --> ${end}`);
+    lines.push(text);
+    lines.push('');
+  });
+
+  return lines.join('\n');
+}
+
+/**
+ * Format seconds to SRT time format (HH:MM:SS,mmm)
+ */
+function formatTimeSrt(seconds) {
+  const h = Math.floor(seconds / 3600);
+  const m = Math.floor((seconds % 3600) / 60);
+  const s = Math.floor(seconds % 60);
+  const ms = Math.floor((seconds % 1) * 1000);
+
+  return `${h.toString().padStart(2, '0')}:${m.toString().padStart(2, '0')}:${s.toString().padStart(2, '0')},${ms.toString().padStart(3, '0')}`;
+}
+
+/**
+ * Format seconds to VTT time format (HH:MM:SS.mmm)
+ */
+function formatTimeVtt(seconds) {
+  const h = Math.floor(seconds / 3600);
+  const m = Math.floor((seconds % 3600) / 60);
+  const s = Math.floor(seconds % 60);
+  const ms = Math.floor((seconds % 1) * 1000);
+
+  return `${h.toString().padStart(2, '0')}:${m.toString().padStart(2, '0')}:${s.toString().padStart(2, '0')}.${ms.toString().padStart(3, '0')}`;
+}
+
+/**
+ * Main transcribe command handler
+ */
+export async function transcribeCommand(file, options, command) {
+  // Check auth
+  const apiKey = command?.parent?.opts()?.apiKey || getApiKey();
+  if (!apiKey) {
+    error('Not authenticated. Run `meetscribe login` first.');
+    process.exit(1);
+  }
+
+  // Check file exists
+  const filePath = path.resolve(file);
+  if (!fs.existsSync(filePath)) {
+    error(`File not found: ${filePath}`);
+    process.exit(1);
+  }
+
+  const stat = fs.statSync(filePath);
+  const fileSizeMB = (stat.size / (1024 * 1024)).toFixed(2);
+  const fileName = path.basename(filePath);
+
+  console.log();
+  info(`Transcribing: ${fileName} (${fileSizeMB} MB)`);
+  console.log();
+
+  const client = new MeetScribeClient({
+    apiKey,
+    baseUrl: command?.parent?.opts()?.apiUrl || getApiUrl()
+  });
+
+  // Upload file
+  const uploadSpinner = ora('Uploading file...').start();
+
+  let uploadProgress = 0;
+  const onProgress = (progressEvent) => {
+    if (progressEvent.total) {
+      const percent = Math.round((progressEvent.loaded / progressEvent.total) * 100);
+      if (percent > uploadProgress) {
+        uploadProgress = percent;
+        uploadSpinner.text = `Uploading file... ${percent}%`;
+      }
+    }
+  };
+
+  try {
+    const response = await client.transcribe(filePath, {
+      language: options.language,
+      speakers: options.speakers ? parseInt(options.speakers) : undefined,
+      onProgress
+    });
+
+    uploadSpinner.succeed('File uploaded');
+
+    const jobId = response.data?.job_id || response.job_id;
+
+    if (!jobId) {
+      error('Server did not return job ID');
+      console.log(chalk.dim(JSON.stringify(response, null, 2)));
+      process.exit(1);
+    }
+
+    // If --no-wait, just return job ID
+    if (options.wait === false) {
+      console.log();
+      success(`Job created: ${jobId}`);
+      console.log();
+      console.log(chalk.dim('Check status with:'));
+      console.log(chalk.cyan(`  meetscribe status ${jobId}`));
+      console.log();
+      return;
+    }
+
+    // Wait for completion
+    const waitSpinner = ora('Processing transcription...').start();
+    let lastStatus = '';
+
+    try {
+      const result = await client.waitForJob(jobId, {
+        pollInterval: 3000,
+        onProgress: (status) => {
+          const statusText = status.data?.status_details || status.data?.status || 'processing';
+          if (statusText !== lastStatus) {
+            lastStatus = statusText;
+            waitSpinner.text = `Processing: ${statusText}`;
+          }
+        }
+      });
+
+      waitSpinner.succeed('Transcription complete');
+
+      // Format output
+      const output = formatOutput(result, options.format);
+
+      // Save to file or print
+      if (options.output) {
+        const outputPath = path.resolve(options.output);
+        fs.writeFileSync(outputPath, output);
+        console.log();
+        success(`Saved to: ${outputPath}`);
+      } else {
+        console.log();
+        console.log(output);
+      }
+
+      // Show summary
+      const data = result.data || result;
+      if (data.duration) {
+        console.log();
+        console.log(chalk.dim(`Duration: ${formatDuration(data.duration)}`));
+      }
+
+    } catch (err) {
+      waitSpinner.fail('Transcription failed');
+      error(err.message);
+      process.exit(1);
+    }
+
+  } catch (err) {
+    uploadSpinner.fail('Upload failed');
+    error(err.message);
+
+    if (err.code === 'ECONNREFUSED') {
+      console.log();
+      info('Cannot connect to API server. Check your internet connection or API URL.');
+    }
+
+    process.exit(1);
+  }
+}

package/src/cli/commands/whoami.js

@@ -0,0 +1,79 @@
+/**
+ * Whoami command - show current user info
+ */
+
+import chalk from 'chalk';
+import ora from 'ora';
+
+import { getApiKey, getApiUrl, isAuthenticated } from '../utils/config.js';
+import { MeetScribeClient } from '../../sdk/client.js';
+import { error, info } from '../utils/output.js';
+
+export async function whoamiCommand(options, command) {
+  if (!isAuthenticated()) {
+    console.log();
+    info('Not logged in');
+    console.log();
+    console.log(chalk.dim('Run `meetscribe login` to authenticate'));
+    console.log();
+    return;
+  }
+
+  const apiKey = command?.parent?.opts()?.apiKey || getApiKey();
+
+  const client = new MeetScribeClient({
+    apiKey,
+    baseUrl: command?.parent?.opts()?.apiUrl || getApiUrl()
+  });
+
+  const spinner = ora('Fetching account info...').start();
+
+  try {
+    const result = await client.getAccount();
+    spinner.stop();
+
+    const account = result.data || result;
+
+    console.log();
+    console.log(chalk.bold('Account Info'));
+    console.log();
+    console.log(`  Username:  ${chalk.cyan(account.username || account.name || '-')}`);
+
+    if (account.email) {
+      console.log(`  Email:     ${account.email}`);
+    }
+
+    if (account.telegram_id) {
+      console.log(`  Telegram:  ${account.telegram_id}`);
+    }
+
+    if (account.plan) {
+      console.log(`  Plan:      ${account.plan}`);
+    }
+
+    // Show API key info
+    const maskedKey = apiKey.slice(0, 8) + '...' + apiKey.slice(-4);
+    console.log(`  API Key:   ${chalk.dim(maskedKey)}`);
+
+    console.log();
+
+    // Show usage if available
+    if (account.usage) {
+      console.log(chalk.bold('Usage'));
+      console.log();
+      console.log(`  Today:     ${account.usage.today || 0} requests`);
+      console.log(`  Total:     ${account.usage.total || 0} requests`);
+      console.log();
+    }
+
+  } catch (err) {
+    spinner.fail('Failed to fetch account info');
+    error(err.message);
+
+    // Show basic info anyway
+    console.log();
+    const maskedKey = apiKey.slice(0, 8) + '...' + apiKey.slice(-4);
+    console.log(`  API Key: ${chalk.dim(maskedKey)}`);
+    console.log();
+  }
+}

package/src/cli/index.js

@@ -0,0 +1,114 @@
+/**
+ * MeetScribe CLI Entry Point
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+
+import { loginCommand } from './commands/login.js';
+import { configCommand } from './commands/config.js';
+import { transcribeCommand } from './commands/transcribe.js';
+import { statusCommand } from './commands/status.js';
+import { listCommand } from './commands/list.js';
+import { protocolCommand } from './commands/protocol.js';
+import { whoamiCommand } from './commands/whoami.js';
+
+const VERSION = '1.0.0';
+
+export function cli() {
+  const program = new Command();
+
+  program
+    .name('meetscribe')
+    .description('MeetScribe CLI - Meeting transcription and protocol generation')
+    .version(VERSION)
+    .option('--api-key <key>', 'API key (overrides config)')
+    .option('--api-url <url>', 'API URL (overrides config)');
+
+  // Auth commands
+  program
+    .command('login')
+    .description('Authenticate with MeetScribe')
+    .option('--device', 'Use device flow (for servers without browser)')
+    .option('--key', 'Enter API key manually')
+    .action(loginCommand);
+
+  program
+    .command('logout')
+    .description('Remove saved API key')
+    .action(async () => {
+      const { clearConfig } = await import('./utils/config.js');
+      clearConfig();
+      console.log(chalk.green('✓'), 'Logged out successfully');
+    });
+
+  program
+    .command('whoami')
+    .description('Show current user info')
+    .action(whoamiCommand);
+
+  // Config commands
+  const config = program
+    .command('config')
+    .description('Manage configuration');
+
+  config
+    .command('show')
+    .description('Show current configuration')
+    .action(() => configCommand('show'));
+
+  config
+    .command('set-key <key>')
+    .description('Set API key')
+    .action((key) => configCommand('set-key', key));
+
+  config
+    .command('set-url <url>')
+    .description('Set API URL')
+    .action((url) => configCommand('set-url', url));
+
+  config
+    .command('set-language <lang>')
+    .description('Set default language (ru, en, auto)')
+    .action((lang) => configCommand('set-language', lang));
+
+  config
+    .command('reset')
+    .description('Reset configuration to defaults')
+    .action(() => configCommand('reset'));
+
+  // Main commands
+  program
+    .command('transcribe <file>')
+    .description('Transcribe audio/video file')
+    .option('-l, --language <lang>', 'Language (ru, en, auto)', 'auto')
+    .option('-s, --speakers <num>', 'Number of speakers for diarization')
+    .option('-o, --output <file>', 'Output file path')
+    .option('-f, --format <format>', 'Output format (json, txt, srt, vtt)', 'json')
+    .option('--no-wait', 'Return job ID immediately without waiting')
+    .action(transcribeCommand);
+
+  program
+    .command('status <jobId>')
+    .description('Check job status')
+    .action(statusCommand);
+
+  program
+    .command('list')
+    .alias('ls')
+    .description('List transcribed materials')
+    .option('-n, --limit <num>', 'Number of items', '20')
+    .option('--status <status>', 'Filter by status (pending, processing, completed, error)')
+    .option('-f, --format <format>', 'Output format (table, json)', 'table')
+    .action(listCommand);
+
+  program
+    .command('protocol <materialId>')
+    .description('Get meeting protocol')
+    .option('-f, --format <format>', 'Output format (json, markdown, txt)', 'json')
+    .option('-o, --output <file>', 'Output file path')
+    .action(protocolCommand);
+
+  // Parse and run
+  program.parse();
+}