meetscribe 1.0.0

package/src/cli/utils/config.js

@@ -0,0 +1,89 @@
+/**
+ * Configuration management for MeetScribe CLI
+ * Stores config in ~/.meetscribe/config.json
+ */
+
+import Conf from 'conf';
+
+const config = new Conf({
+  projectName: 'meetscribe',
+  schema: {
+    apiKey: {
+      type: 'string',
+      default: ''
+    },
+    apiUrl: {
+      type: 'string',
+      default: 'https://api.meetscribe.ru/v1'
+    },
+    defaultLanguage: {
+      type: 'string',
+      enum: ['ru', 'en', 'auto'],
+      default: 'auto'
+    },
+    defaultFormat: {
+      type: 'string',
+      enum: ['json', 'txt', 'srt', 'vtt', 'markdown'],
+      default: 'json'
+    }
+  }
+});
+
+export default config;
+
+/**
+ * Get API key from environment or config
+ */
+export function getApiKey() {
+  // Priority: env > config
+  return process.env.MEETSCRIBE_API_KEY || config.get('apiKey');
+}
+
+/**
+ * Get API URL from environment or config
+ */
+export function getApiUrl() {
+  return process.env.MEETSCRIBE_API_URL || config.get('apiUrl');
+}
+
+/**
+ * Check if user is authenticated
+ */
+export function isAuthenticated() {
+  return Boolean(getApiKey());
+}
+
+/**
+ * Set API key
+ */
+export function setApiKey(key) {
+  config.set('apiKey', key);
+}
+
+/**
+ * Clear all config
+ */
+export function clearConfig() {
+  config.clear();
+}
+
+/**
+ * Get all config values
+ */
+export function getAllConfig() {
+  return {
+    apiKey: config.get('apiKey') ? maskApiKey(config.get('apiKey')) : '(not set)',
+    apiUrl: config.get('apiUrl'),
+    defaultLanguage: config.get('defaultLanguage'),
+    defaultFormat: config.get('defaultFormat'),
+    configPath: config.path
+  };
+}
+
+/**
+ * Mask API key for display
+ */
+function maskApiKey(key) {
+  if (!key || key.length < 12) return '****';
+  return key.slice(0, 8) + '...' + key.slice(-4);
+}

package/src/cli/utils/output.js

@@ -0,0 +1,100 @@
+/**
+ * Output formatting utilities
+ */
+
+import chalk from 'chalk';
+
+/**
+ * Print success message
+ */
+export function success(message) {
+  console.log(chalk.green('✓'), message);
+}
+
+/**
+ * Print error message
+ */
+export function error(message) {
+  console.error(chalk.red('✗'), message);
+}
+
+/**
+ * Print warning message
+ */
+export function warn(message) {
+  console.log(chalk.yellow('⚠'), message);
+}
+
+/**
+ * Print info message
+ */
+export function info(message) {
+  console.log(chalk.blue('ℹ'), message);
+}
+
+/**
+ * Print JSON output
+ */
+export function json(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+
+/**
+ * Print table
+ */
+export function table(headers, rows) {
+  // Calculate column widths
+  const widths = headers.map((h, i) => {
+    const maxRow = Math.max(...rows.map(r => String(r[i] || '').length));
+    return Math.max(h.length, maxRow);
+  });
+
+  // Print header
+  const headerLine = headers.map((h, i) => h.padEnd(widths[i])).join('  ');
+  console.log(chalk.bold(headerLine));
+  console.log('-'.repeat(headerLine.length));
+
+  // Print rows
+  rows.forEach(row => {
+    const line = row.map((cell, i) => String(cell || '').padEnd(widths[i])).join('  ');
+    console.log(line);
+  });
+}
+
+/**
+ * Format duration in seconds to HH:MM:SS
+ */
+export function formatDuration(seconds) {
+  const h = Math.floor(seconds / 3600);
+  const m = Math.floor((seconds % 3600) / 60);
+  const s = Math.floor(seconds % 60);
+
+  if (h > 0) {
+    return `${h}:${m.toString().padStart(2, '0')}:${s.toString().padStart(2, '0')}`;
+  }
+  return `${m}:${s.toString().padStart(2, '0')}`;
+}
+
+/**
+ * Format date
+ */
+export function formatDate(dateString) {
+  const date = new Date(dateString);
+  return date.toLocaleString();
+}
+
+/**
+ * Status badge with color
+ */
+export function statusBadge(status) {
+  const colors = {
+    pending: chalk.yellow,
+    processing: chalk.blue,
+    completed: chalk.green,
+    error: chalk.red,
+    failed: chalk.red
+  };
+
+  const color = colors[status] || chalk.gray;
+  return color(status);
+}

package/src/index.js

@@ -0,0 +1,7 @@
+/**
+ * MeetScribe SDK
+ * Programmatic access to MeetScribe API
+ */
+
+export { MeetScribeClient } from './sdk/client.js';
+export { default as config } from './cli/utils/config.js';

package/src/sdk/client.js

@@ -0,0 +1,211 @@
+/**
+ * MeetScribe API Client
+ */
+
+import axios from 'axios';
+import FormData from 'form-data';
+import fs from 'fs';
+import path from 'path';
+import mime from 'mime-types';
+
+export class MeetScribeClient {
+  constructor(options = {}) {
+    this.apiKey = options.apiKey;
+    this.baseUrl = options.baseUrl || 'https://api.meetscribe.ru/v1';
+    this.timeout = options.timeout || 300000; // 5 minutes default
+
+    this.client = axios.create({
+      baseURL: this.baseUrl,
+      timeout: this.timeout,
+      headers: {
+        'X-API-Key': this.apiKey,
+        'User-Agent': 'meetscribe-cli/1.0.0'
+      }
+    });
+
+    // Add response interceptor for error handling
+    this.client.interceptors.response.use(
+      response => response,
+      error => {
+        if (error.response) {
+          const { status, data } = error.response;
+          const message = data?.error?.message || data?.message || 'API Error';
+          const code = data?.error?.code || 'api_error';
+
+          const apiError = new Error(message);
+          apiError.code = code;
+          apiError.status = status;
+          apiError.response = error.response;
+
+          throw apiError;
+        }
+
+        if (error.code === 'ECONNREFUSED') {
+          const connError = new Error('Cannot connect to API server');
+          connError.code = 'connection_error';
+          throw connError;
+        }
+
+        throw error;
+      }
+    );
+  }
+
+  /**
+   * Upload and transcribe a file
+   */
+  async transcribe(filePath, options = {}) {
+    const absolutePath = path.resolve(filePath);
+
+    if (!fs.existsSync(absolutePath)) {
+      throw new Error(`File not found: ${absolutePath}`);
+    }
+
+    const stat = fs.statSync(absolutePath);
+    const fileName = path.basename(absolutePath);
+    const mimeType = mime.lookup(absolutePath) || 'application/octet-stream';
+
+    const form = new FormData();
+    form.append('file', fs.createReadStream(absolutePath), {
+      filename: fileName,
+      contentType: mimeType,
+      knownLength: stat.size
+    });
+
+    if (options.language) {
+      form.append('language', options.language);
+    }
+
+    if (options.speakers) {
+      form.append('speakers', String(options.speakers));
+    }
+
+    if (options.webhookUrl) {
+      form.append('webhook_url', options.webhookUrl);
+    }
+
+    const response = await this.client.post('/transcribe', form, {
+      headers: {
+        ...form.getHeaders()
+      },
+      maxContentLength: Infinity,
+      maxBodyLength: Infinity,
+      onUploadProgress: options.onProgress
+    });
+
+    return response.data;
+  }
+
+  /**
+   * Get job status
+   */
+  async getJobStatus(jobId) {
+    const response = await this.client.get(`/jobs/${jobId}`);
+    return response.data;
+  }
+
+  /**
+   * Wait for job to complete
+   */
+  async waitForJob(jobId, options = {}) {
+    const pollInterval = options.pollInterval || 3000;
+    const maxWait = options.maxWait || 3600000; // 1 hour
+    const onProgress = options.onProgress;
+
+    const startTime = Date.now();
+
+    while (true) {
+      const result = await this.getJobStatus(jobId);
+
+      if (onProgress) {
+        onProgress(result);
+      }
+
+      if (result.data?.status === 'completed') {
+        return result;
+      }
+
+      if (result.data?.status === 'error' || result.data?.status === 'failed') {
+        throw new Error(result.data?.error || 'Job failed');
+      }
+
+      if (Date.now() - startTime > maxWait) {
+        throw new Error('Timeout waiting for job completion');
+      }
+
+      await new Promise(resolve => setTimeout(resolve, pollInterval));
+    }
+  }
+
+  /**
+   * Get material details
+   */
+  async getMaterial(materialId) {
+    const response = await this.client.get(`/materials/${materialId}`);
+    return response.data;
+  }
+
+  /**
+   * List materials
+   */
+  async listMaterials(options = {}) {
+    const params = new URLSearchParams();
+
+    if (options.page) params.append('page', options.page);
+    if (options.perPage) params.append('per_page', options.perPage);
+    if (options.status) params.append('status', options.status);
+
+    const response = await this.client.get(`/materials?${params}`);
+    return response.data;
+  }
+
+  /**
+   * Get protocol for material
+   */
+  async getProtocol(materialId) {
+    const response = await this.client.get(`/materials/${materialId}/protocol`);
+    return response.data;
+  }
+
+  /**
+   * Get transcript for material
+   */
+  async getTranscript(materialId) {
+    const response = await this.client.get(`/materials/${materialId}/transcript`);
+    return response.data;
+  }
+
+  /**
+   * Get account info
+   */
+  async getAccount() {
+    const response = await this.client.get('/account');
+    return response.data;
+  }
+
+  /**
+   * Get usage statistics
+   */
+  async getUsage() {
+    const response = await this.client.get('/account/usage');
+    return response.data;
+  }
+
+  /**
+   * CLI Auth: Create session
+   */
+  async createCliSession() {
+    const response = await this.client.post('/cli/session');
+    return response.data;
+  }
+
+  /**
+   * CLI Auth: Poll for session status
+   */
+  async pollCliToken(sessionId) {
+    const response = await this.client.get(`/cli/session/${sessionId}`);
+    return response.data;
+  }
+}
+
+export default MeetScribeClient;

package/types/index.d.ts

@@ -0,0 +1,98 @@
+/**
+ * MeetScribe SDK TypeScript Definitions
+ */
+
+export interface MeetScribeClientOptions {
+  apiKey: string;
+  baseUrl?: string;
+  timeout?: number;
+}
+
+export interface TranscribeOptions {
+  language?: 'ru' | 'en' | 'auto';
+  speakers?: number;
+  webhookUrl?: string;
+  onProgress?: (event: ProgressEvent) => void;
+}
+
+export interface ProgressEvent {
+  loaded: number;
+  total?: number;
+}
+
+export interface JobStatus {
+  job_id: string;
+  status: 'pending' | 'processing' | 'completed' | 'error';
+  progress?: number;
+  status_details?: string;
+  error?: string;
+}
+
+export interface Material {
+  id: string;
+  title: string;
+  status: string;
+  has_protocol: boolean;
+  has_transcript: boolean;
+  created_at: string;
+  updated_at?: string;
+}
+
+export interface Protocol {
+  material_id: string;
+  summary: string;
+  participants_list: Array<{ name: string; role?: string }>;
+  key_points: string[];
+  decisions: string[];
+  action_items: ActionItem[];
+  open_questions: string[];
+  next_meeting?: string;
+}
+
+export interface ActionItem {
+  id: string;
+  text: string;
+  assignee?: string;
+  deadline?: string;
+  priority: 'low' | 'medium' | 'high';
+  status: 'pending' | 'in_progress' | 'done' | 'cancelled';
+}
+
+export interface ApiResponse<T> {
+  success: boolean;
+  data?: T;
+  error?: {
+    code: string;
+    message: string;
+  };
+}
+
+export class MeetScribeClient {
+  constructor(options: MeetScribeClientOptions);
+
+  transcribe(filePath: string, options?: TranscribeOptions): Promise<ApiResponse<{ job_id: string }>>;
+
+  getJobStatus(jobId: string): Promise<ApiResponse<JobStatus>>;
+
+  waitForJob(jobId: string, options?: {
+    pollInterval?: number;
+    maxWait?: number;
+    onProgress?: (status: JobStatus) => void;
+  }): Promise<ApiResponse<JobStatus>>;
+
+  getMaterial(materialId: string): Promise<ApiResponse<Material>>;
+
+  listMaterials(options?: {
+    page?: number;
+    perPage?: number;
+    status?: string;
+  }): Promise<ApiResponse<{ materials: Material[]; pagination: { page: number; total: number } }>>;
+
+  getProtocol(materialId: string): Promise<ApiResponse<Protocol>>;
+
+  getTranscript(materialId: string): Promise<ApiResponse<{ transcript: string }>>;
+
+  getAccount(): Promise<ApiResponse<{ username: string; email?: string; plan?: string }>>;
+
+  getUsage(): Promise<ApiResponse<{ today: number; total: number }>>;
+}