@autoaiai/aicut 0.1.11 → 0.1.13

package/skills/remotion-resemble-ai/rules/resemble-setup.md

@@ -1,284 +0,0 @@
----
-name: resemble-setup
-description: Setting up Resemble.ai API credentials and project configuration
-metadata:
-  tags: resemble, api, setup, configuration, authentication
----
-
-# Setting up Resemble.ai
-
-## Credential Check (Agent Instructions)
-
-When this skill is invoked, ALWAYS perform this check first:
-
-### 1. Check for .env file
-
-```bash
-# Check if .env exists and has the required keys
-cat .env 2>/dev/null | grep -E "^RESEMBLE_API_KEY=|^RESEMBLE_VOICE_UUID="
-```
-
-### 2. If credentials are missing, prompt the user
-
-**Missing API Key:**
-```
-I need your Resemble.ai API key to generate voiceovers.
-
-Get your API key from: https://app.resemble.ai/account/api
-
-Please paste your Resemble.ai API key:
-```
-
-**Missing Voice UUID:**
-Use the default voice UUID `7213a9ea`. Only prompt the user if they specifically want to use a different voice.
-
-### 3. Save credentials to .env
-
-After user provides API key, create/update .env with the default voice:
-
-```bash
-# Create .env if it doesn't exist, append if it does
-echo "RESEMBLE_API_KEY=user_provided_key" >> .env
-echo "RESEMBLE_VOICE_UUID=7213a9ea" >> .env  # Default voice
-```
-
-### 4. Ensure .gitignore includes .env
-
-```bash
-# Add .env to .gitignore if not present
-grep -q "^\.env$" .gitignore 2>/dev/null || echo ".env" >> .gitignore
-```
-
----
-
-## Getting API Credentials
-
-1. Create an account at [Resemble.ai](https://app.resemble.ai)
-2. Navigate to Account > API to generate your API token
-3. Store the API key securely (never commit to version control)
-
-## Environment Configuration
-
-Create a `.env` file in your project root:
-
-```env
-RESEMBLE_API_KEY=your_api_key_here
-RESEMBLE_VOICE_UUID=7213a9ea  # Default voice, change if needed
-```
-
-Add `.env` to your `.gitignore`:
-
-```gitignore
-.env
-.env.local
-```
-
-## Project Setup
-
-Install required dependencies:
-
-```bash
-npm install dotenv
-# or
-bun add dotenv
-```
-
-Create a utility file for Resemble.ai API calls:
-
-```typescript
-// src/resemble/client.ts
-import 'dotenv/config';
-
-const RESEMBLE_API_KEY = process.env.RESEMBLE_API_KEY;
-
-if (!RESEMBLE_API_KEY) {
-  throw new Error('RESEMBLE_API_KEY environment variable is required');
-}
-
-export const resembleConfig = {
-  apiKey: RESEMBLE_API_KEY,
-  baseUrl: 'https://f.cluster.resemble.ai',
-};
-
-export async function callResembleApi<T>(
-  endpoint: string,
-  options: RequestInit = {}
-): Promise<T> {
-  const response = await fetch(`${resembleConfig.baseUrl}${endpoint}`, {
-    ...options,
-    headers: {
-      'Authorization': resembleConfig.apiKey,
-      'Content-Type': 'application/json',
-      ...options.headers,
-    },
-  });
-
-  if (!response.ok) {
-    throw new Error(`Resemble API error: ${response.status} ${response.statusText}`);
-  }
-
-  return response.json();
-}
-```
-
-## Type Definitions
-
-Create TypeScript types for Resemble.ai responses:
-
-```typescript
-// src/resemble/types.ts
-export interface SynthesizeRequest {
-  voice_uuid: string;
-  data: string;
-  project_uuid?: string;
-  title?: string;
-  model?: 'chatterbox-turbo' | string;
-  precision?: 'MULAW' | 'PCM_16' | 'PCM_24' | 'PCM_32';
-  output_format?: 'wav' | 'mp3';
-  sample_rate?: 8000 | 16000 | 22050 | 32000 | 44100 | 48000;
-  use_hd?: boolean;
-}
-
-export interface AudioTimestamps {
-  graph_chars: string[];
-  graph_times: [number, number][];
-  phon_chars: string[];
-  phon_times: [number, number][];
-}
-
-export interface SynthesizeResponse {
-  audio_content: string; // Base64 encoded
-  audio_timestamps: AudioTimestamps;
-  duration: number;
-  issues: string[];
-  output_format: string;
-  sample_rate: number;
-  seed: number;
-  success: boolean;
-  synth_duration: number;
-  title: string | null;
-}
-
-export interface Voice {
-  uuid: string;
-  name: string;
-  // Additional voice properties
-}
-
-export interface VoicesResponse {
-  success: boolean;
-  page: number;
-  num_pages: number;
-  page_size: number;
-  items: Voice[];
-}
-```
-
-## Recommended Project Structure
-
-```
-your-remotion-project/
-├── src/
-│   ├── resemble/
-│   │   ├── client.ts        # API client
-│   │   ├── types.ts         # TypeScript types
-│   │   ├── synthesize.ts    # TTS functions
-│   │   └── voices.ts        # Voice management
-│   ├── compositions/
-│   │   └── MyVideo.tsx      # Remotion composition
-│   └── Root.tsx
-├── public/
-│   └── audio/               # Generated audio files
-├── .env
-├── .gitignore
-└── package.json
-```
-
-## Rate Limits and Best Practices
-
-- Resemble.ai has rate limits based on your plan
-- Cache generated audio files to avoid regenerating the same content
-- Use the synchronous endpoint for content up to 2,000 characters
-- For longer scripts, use streaming or split into multiple requests
-- Store generated audio in `public/` for easy access in Remotion
-
-## Credential Validation Utility
-
-Use this to verify credentials are working:
-
-```typescript
-// src/resemble/validate.ts
-import 'dotenv/config';
-
-interface ValidationResult {
-  isValid: boolean;
-  apiKeyPresent: boolean;
-  voiceUuidPresent: boolean;
-  apiKeyWorks?: boolean;
-  error?: string;
-}
-
-export async function validateResembleConfig(): Promise<ValidationResult> {
-  const apiKey = process.env.RESEMBLE_API_KEY;
-  const voiceUuid = process.env.RESEMBLE_VOICE_UUID;
-
-  const result: ValidationResult = {
-    isValid: false,
-    apiKeyPresent: !!apiKey,
-    voiceUuidPresent: !!voiceUuid,
-  };
-
-  if (!apiKey) {
-    result.error = 'RESEMBLE_API_KEY is not set in .env';
-    return result;
-  }
-
-  if (!voiceUuid) {
-    result.error = 'RESEMBLE_VOICE_UUID is not set in .env';
-    return result;
-  }
-
-  // Test API key by making a simple request
-  try {
-    const response = await fetch('https://app.resemble.ai/api/v2/voices?page=1&page_size=1', {
-      headers: {
-        'Authorization': `Token token=${apiKey}`,
-        'Content-Type': 'application/json',
-      },
-    });
-
-    result.apiKeyWorks = response.ok;
-
-    if (!response.ok) {
-      result.error = `API key validation failed: ${response.status}`;
-      return result;
-    }
-
-    result.isValid = true;
-  } catch (error) {
-    result.error = `Connection error: ${error instanceof Error ? error.message : 'Unknown'}`;
-  }
-
-  return result;
-}
-
-// CLI usage
-if (require.main === module) {
-  validateResembleConfig().then((result) => {
-    console.log('Resemble.ai Configuration Status:');
-    console.log('─'.repeat(40));
-    console.log(`API Key Present: ${result.apiKeyPresent ? '✓' : '✗'}`);
-    console.log(`Voice UUID Present: ${result.voiceUuidPresent ? '✓' : '✗'}`);
-    console.log(`API Key Valid: ${result.apiKeyWorks ? '✓' : '✗'}`);
-    console.log('─'.repeat(40));
-    console.log(`Overall: ${result.isValid ? '✓ Ready to use' : '✗ ' + result.error}`);
-    process.exit(result.isValid ? 0 : 1);
-  });
-}
-```
-
-Run validation:
-
-```bash
-npx tsx src/resemble/validate.ts
-```

package/skills/remotion-resemble-ai/rules/resemble-streaming-tts.md

@@ -1,225 +0,0 @@
----
-name: resemble-streaming-tts
-description: Streaming text-to-speech generation for longer content
-metadata:
-  tags: resemble, tts, streaming, audio, speech, http
----
-
-# Streaming Text-to-Speech
-
-Use streaming for longer scripts where you want to start processing audio before synthesis completes. The response is chunked WAV data.
-
-## Endpoint
-
-`POST https://f.cluster.resemble.ai/stream`
-
-> **Note:** Streaming requests target dedicated synthesis hosts. Check your Resemble.ai dashboard for your specific streaming endpoint.
-
-## Basic Streaming Implementation
-
-```typescript
-// src/resemble/stream.ts
-import { createWriteStream } from 'fs';
-import { pipeline } from 'stream/promises';
-import { Readable } from 'stream';
-import { resembleConfig } from './client';
-
-interface StreamOptions {
-  voice_uuid: string;
-  data: string;
-  precision?: 'PCM_16' | 'PCM_24' | 'PCM_32' | 'MULAW';
-  sample_rate?: number;
-  use_hd?: boolean;
-  model?: string;
-}
-
-export async function streamSpeechToFile(
-  options: StreamOptions,
-  outputPath: string
-): Promise<void> {
-  const response = await fetch(`${resembleConfig.baseUrl}/stream`, {
-    method: 'POST',
-    headers: {
-      'Authorization': `Bearer ${resembleConfig.apiKey}`,
-      'Content-Type': 'application/json',
-    },
-    body: JSON.stringify({
-      voice_uuid: options.voice_uuid,
-      data: options.data,
-      precision: options.precision || 'PCM_16',
-      sample_rate: options.sample_rate || 48000,
-      use_hd: options.use_hd || false,
-    }),
-  });
-
-  if (!response.ok) {
-    throw new Error(`Stream request failed: ${response.status}`);
-  }
-
-  if (!response.body) {
-    throw new Error('No response body');
-  }
-
-  // Convert web ReadableStream to Node.js Readable
-  const nodeStream = Readable.fromWeb(response.body as any);
-  const fileStream = createWriteStream(outputPath);
-
-  await pipeline(nodeStream, fileStream);
-}
-```
-
-## Streaming with Progress Callback
-
-```typescript
-// src/resemble/stream.ts
-export async function streamSpeechWithProgress(
-  options: StreamOptions,
-  outputPath: string,
-  onProgress?: (bytesReceived: number) => void
-): Promise<{ totalBytes: number }> {
-  const response = await fetch(`${resembleConfig.baseUrl}/stream`, {
-    method: 'POST',
-    headers: {
-      'Authorization': `Bearer ${resembleConfig.apiKey}`,
-      'Content-Type': 'application/json',
-    },
-    body: JSON.stringify({
-      voice_uuid: options.voice_uuid,
-      data: options.data,
-      precision: options.precision || 'PCM_16',
-      sample_rate: options.sample_rate || 48000,
-    }),
-  });
-
-  if (!response.ok) {
-    throw new Error(`Stream request failed: ${response.status}`);
-  }
-
-  const reader = response.body?.getReader();
-  if (!reader) {
-    throw new Error('No response reader');
-  }
-
-  const chunks: Uint8Array[] = [];
-  let totalBytes = 0;
-
-  while (true) {
-    const { done, value } = await reader.read();
-
-    if (done) break;
-
-    chunks.push(value);
-    totalBytes += value.length;
-
-    onProgress?.(totalBytes);
-  }
-
-  // Combine all chunks
-  const audioData = new Uint8Array(totalBytes);
-  let offset = 0;
-  for (const chunk of chunks) {
-    audioData.set(chunk, offset);
-    offset += chunk.length;
-  }
-
-  // Write to file
-  const fs = await import('fs');
-  fs.writeFileSync(outputPath, audioData);
-
-  return { totalBytes };
-}
-```
-
-## Usage Example
-
-```typescript
-// scripts/stream-voiceover.ts
-import { join } from 'path';
-import { streamSpeechWithProgress } from '../src/resemble/stream';
-
-const VOICE_UUID = 'your-voice-uuid';
-
-async function main() {
-  const longScript = `
-    Welcome to our comprehensive tutorial.
-    In this video, we'll cover everything you need to know about our platform.
-
-    First, let's start with the basics.
-    Our platform is designed to be intuitive and easy to use.
-
-    Next, we'll explore advanced features.
-    These features will help you become a power user.
-
-    Finally, we'll wrap up with some tips and tricks.
-    Thank you for watching!
-  `.trim();
-
-  console.log('Starting streaming synthesis...');
-
-  const outputPath = join(process.cwd(), 'public', 'audio', 'tutorial.wav');
-
-  const { totalBytes } = await streamSpeechWithProgress(
-    {
-      voice_uuid: VOICE_UUID,
-      data: longScript,
-      precision: 'PCM_16',
-      sample_rate: 48000,
-    },
-    outputPath,
-    (bytesReceived) => {
-      console.log(`Received ${bytesReceived} bytes...`);
-    }
-  );
-
-  console.log(`Complete! Total size: ${totalBytes} bytes`);
-  console.log(`Saved to: ${outputPath}`);
-}
-
-main().catch(console.error);
-```
-
-## Request Parameters
-
-| Parameter | Type | Required | Description |
-|-----------|------|----------|-------------|
-| `voice_uuid` | string | Yes | Voice to synthesize |
-| `data` | string | Yes | Text or SSML (max 2,000 chars) |
-| `precision` | string | No | `PCM_16`, `PCM_24`, `PCM_32`, `MULAW` |
-| `sample_rate` | number | No | 8000-48000 (default: 48000) |
-| `use_hd` | boolean | No | Higher quality synthesis |
-| `model` | string | No | `chatterbox-turbo` for lower latency |
-
-## When to Use Streaming vs Synchronous
-
-| Scenario | Recommended |
-|----------|-------------|
-| Short text (< 500 chars) | Synchronous |
-| Pre-generated video content | Synchronous |
-| Need timestamps immediately | Synchronous |
-| Long scripts (500-2000 chars) | Streaming |
-| Progress indication needed | Streaming |
-| Memory-constrained environments | Streaming |
-
-## Error Handling
-
-```typescript
-export async function streamSpeechSafe(
-  options: StreamOptions,
-  outputPath: string
-): Promise<boolean> {
-  try {
-    if (options.data.length > 2000) {
-      console.error('Text exceeds 2000 character limit');
-      return false;
-    }
-
-    await streamSpeechToFile(options, outputPath);
-    return true;
-  } catch (error) {
-    if (error instanceof Error) {
-      console.error('Streaming error:', error.message);
-    }
-    return false;
-  }
-}
-```