@hasna/skills 0.1.23 → 0.1.25

package/skills/audio/README.md

@@ -0,0 +1,256 @@
+# Audio Generation Skill
+
+A comprehensive Claude Code skill for generating high-quality audio using AI-powered text-to-speech APIs.
+
+## Features
+
+- Multiple TTS providers: ElevenLabs, OpenAI TTS, and Google Text-to-Speech
+- Simple, elegant CLI interface
+- Voice selection and listing
+- Multiple languages support
+- Customizable speech speed
+- Clean TypeScript implementation with full type safety
+- Native fetch API (no external HTTP libraries needed)
+
+## Supported Providers
+
+### ElevenLabs
+- Natural voice synthesis with voice cloning capabilities
+- Models: `eleven_multilingual_v2`, `eleven_flash_v2_5`, `eleven_v3`
+- Multiple languages and voice options
+- Professional-quality audio output
+
+### OpenAI TTS
+- High-quality text-to-speech
+- Models: `tts-1` (fast), `tts-1-hd` (high quality)
+- Voices: alloy, echo, fable, onyx, nova, shimmer
+- Speed control (0.25x to 4.0x)
+
+### Google Text-to-Speech
+- Cloud-based TTS service
+- Wide range of voices and languages
+- Natural-sounding speech synthesis
+- Configurable pitch and speaking rate
+
+## Installation
+
+1. Install Bun (if not already installed):
+```bash
+curl -fsSL https://bun.sh/install | bash
+```
+
+2. Clone and navigate to the skill directory:
+```bash
+git clone https://github.com/hasnaxyz/audio.git
+cd audio
+```
+
+3. Install dependencies:
+```bash
+bun install
+```
+
+4. Set up environment variables:
+```bash
+cp .env.example .env
+# Edit .env and add your API keys
+```
+
+## Configuration
+
+Create a `.env` file with your API keys:
+
+```bash
+ELEVENLABS_API_KEY=your_elevenlabs_api_key_here
+OPENAI_API_KEY=your_openai_api_key_here
+GOOGLE_API_KEY=your_google_api_key_here
+```
+
+### Getting API Keys
+
+- **ElevenLabs**: https://elevenlabs.io/
+- **OpenAI**: https://platform.openai.com/api-keys
+- **Google Cloud**: https://console.cloud.google.com/apis/credentials
+
+## Usage
+
+### Generate Audio
+
+#### ElevenLabs
+```bash
+bun run src/index.ts generate \
+  --provider elevenlabs \
+  --text "Hello world, this is a test of ElevenLabs text to speech" \
+  --voice rachel \
+  --model eleven_multilingual_v2 \
+  --output ./output.mp3
+```
+
+#### OpenAI TTS
+```bash
+bun run src/index.ts generate \
+  --provider openai \
+  --text "Hello world, this is a test of OpenAI text to speech" \
+  --voice nova \
+  --model tts-1-hd \
+  --speed 1.0 \
+  --output ./output.mp3
+```
+
+#### Google Text-to-Speech
+```bash
+bun run src/index.ts generate \
+  --provider google \
+  --text "Hello world, this is a test of Google text to speech" \
+  --language en-US \
+  --speed 1.0 \
+  --output ./output.mp3
+```
+
+### List Available Voices
+
+```bash
+# ElevenLabs voices
+bun run src/index.ts voices --provider elevenlabs
+
+# OpenAI voices
+bun run src/index.ts voices --provider openai
+
+# Google voices
+bun run src/index.ts voices --provider google
+```
+
+### Show Help
+
+```bash
+bun run src/index.ts help
+```
+
+## CLI Options
+
+### Generate Command
+
+| Option | Description | Required | Default |
+|--------|-------------|----------|---------|
+| `--provider` | Provider to use (elevenlabs, openai, google) | Yes | - |
+| `--text` | Text to convert to speech | Yes | - |
+| `--output` | Output file path (e.g., ./output.mp3) | Yes | - |
+| `--voice` | Voice to use (provider-specific) | No | Provider default |
+| `--model` | Model to use (provider-specific) | No | Provider default |
+| `--language` | Language code (Google TTS, e.g., en-US) | No | en-US |
+| `--speed` | Speaking speed (0.25-4.0) | No | 1.0 |
+
+### Voices Command
+
+| Option | Description | Required |
+|--------|-------------|----------|
+| `--provider` | Provider to list voices from | Yes |
+
+## Examples
+
+### Quick Test with Different Providers
+
+```bash
+# ElevenLabs - Natural voice
+bun run src/index.ts generate \
+  --provider elevenlabs \
+  --text "The quick brown fox jumps over the lazy dog" \
+  --voice rachel \
+  --output ./elevenlabs_test.mp3
+
+# OpenAI - High quality
+bun run src/index.ts generate \
+  --provider openai \
+  --text "The quick brown fox jumps over the lazy dog" \
+  --voice nova \
+  --model tts-1-hd \
+  --output ./openai_test.mp3
+
+# Google - Multilingual
+bun run src/index.ts generate \
+  --provider google \
+  --text "The quick brown fox jumps over the lazy dog" \
+  --language en-US \
+  --output ./google_test.mp3
+```
+
+### Generate with Custom Speed
+
+```bash
+# Slower speech
+bun run src/index.ts generate \
+  --provider openai \
+  --text "This is spoken slowly" \
+  --voice onyx \
+  --speed 0.75 \
+  --output ./slow.mp3
+
+# Faster speech
+bun run src/index.ts generate \
+  --provider openai \
+  --text "This is spoken quickly" \
+  --voice nova \
+  --speed 1.5 \
+  --output ./fast.mp3
+```
+
+## Project Structure
+
+```
+audio/
+├── SKILL.md              # Skill metadata and description
+├── README.md             # This file
+├── package.json          # Bun project configuration
+├── tsconfig.json         # TypeScript configuration
+├── .env.example          # Example environment variables
+├── src/
+│   ├── index.ts          # CLI entry point
+│   ├── types.ts          # TypeScript type definitions
+│   └── providers/
+│       ├── elevenlabs.ts # ElevenLabs provider
+│       ├── openai.ts     # OpenAI TTS provider
+│       └── google.ts     # Google TTS provider
+```
+
+## Development
+
+### Run in Development Mode
+
+```bash
+bun run dev
+```
+
+### Type Checking
+
+```bash
+bun run tsc --noEmit
+```
+
+## Error Handling
+
+The CLI provides clear error messages for common issues:
+
+- Missing API keys
+- Invalid providers
+- Voice not found
+- API errors
+- File write errors
+
+## Troubleshooting
+
+### "API key not found" error
+Make sure you've created a `.env` file with the appropriate API key for the provider you're using.
+
+### "Voice not found" error
+Use the `voices` command to list available voices for your chosen provider.
+
+### API errors
+Check that your API keys are valid and have sufficient credits/quota.
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit issues or pull requests.

package/skills/audio/SKILL.md

@@ -0,0 +1,35 @@
+---
+name: audio
+description: Generate speech and audio using OpenAI, Minimax, or Gemini through the hosted Skills runtime with provider-cost pricing.
+---
+
+# Audio Generation Skill
+
+Generate speech or short audio from text using provider-backed audio models. This skill routes through the hosted Skills runtime so billing can reserve the selected provider/model cost before execution.
+
+## Supported Providers
+
+- `openai`: `tts-1`, `tts-1-hd`
+- `minimax`: `speech-2.8-turbo`, `speech-2.8-hd`
+- `gemini`: `gemini-2.5-flash-preview-tts`, `gemini-2.5-pro-preview-tts`
+
+## Usage
+
+```bash
+audio generate --provider openai --text "Welcome to Skills.md" --voice alloy --output ./voice.mp3
+audio generate --provider minimax --model speech-2.8-turbo --text "Fast narration" --output ./voice.mp3
+audio generate --provider gemini --text "Studio announcement" --output ./voice.wav
+```
+
+## Options
+
+- `--provider`: `openai`, `minimax`, or `gemini`
+- `--model`: provider model override
+- `--text`: text to synthesize
+- `--voice`: provider-specific voice
+- `--format`: output format such as `mp3`, `wav`, or `opus`
+- `--output`: output file path
+
+## Environment
+
+- `SKILL_API_KEY`: required for hosted runtime execution

package/skills/audio/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "audio",
+  "version": "1.0.0",
+  "description": "Generate speech and audio using provider-cost AI backends",
+  "type": "module",
+  "main": "src/index.ts",
+  "bin": {
+    "audio": "src/index.ts"
+  },
+  "scripts": {
+    "start": "bun run src/index.ts",
+    "dev": "bun run --watch src/index.ts"
+  },
+  "keywords": [
+    "audio-generation",
+    "speech",
+    "tts",
+    "ai",
+    "openai",
+    "minimax",
+    "gemini"
+  ],
+  "author": "",
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  }
+}

package/skills/audio/src/index-local.ts

@@ -0,0 +1,206 @@
+#!/usr/bin/env bun
+
+/**
+ * Audio Generation CLI
+ * Unified interface for ElevenLabs, OpenAI TTS, and Google Text-to-Speech
+ */
+import { handleInstallCommand } from '../../_common';
+
+
+// Handle install/uninstall commands
+const SKILL_META = {
+  name: 'audio',
+  description: 'Audio generation skill for Claude Code using ElevenLabs, OpenAI TTS, and Google Text-to-Speech',
+  version: '1.0.0',
+  commands: `Use: audio --help`,
+  requiredEnvVars: ['SKILL_API_KEY'],
+};
+
+if (await handleInstallCommand(SKILL_META, process.argv.slice(2))) {
+  process.exit(0);
+}
+
+import { MinimaxProvider } from './providers/minimax';
+import { ElevenLabsProvider } from './providers/elevenlabs';
+import { OpenAIProvider } from './providers/openai';
+import { GoogleProvider } from './providers/google';
+import type { AudioProvider, Provider } from './types';
+
+// Parse command line arguments
+function parseArgs(): {
+  command: string;
+  provider?: Provider;
+  text?: string;
+  voice?: string;
+  model?: string;
+  output?: string;
+  language?: string;
+  speed?: number;
+} {
+  const args = process.argv.slice(2);
+  const parsed: any = { command: args[0] || 'help' };
+
+  for (let i = 1; i < args.length; i += 2) {
+    const key = args[i].replace(/^--/, '');
+    const value = args[i + 1];
+    parsed[key] = value;
+  }
+
+  // Convert speed to number if present
+  if (parsed.speed) {
+    parsed.speed = parseFloat(parsed.speed);
+  }
+
+  return parsed;
+}
+
+// Get provider instance
+function getProvider(providerName: Provider): AudioProvider {
+  switch (providerName) {
+    case 'minimax':
+      return new MinimaxProvider();
+    case 'elevenlabs':
+      return new ElevenLabsProvider();
+    case 'openai':
+      return new OpenAIProvider();
+    case 'google':
+      return new GoogleProvider();
+    default:
+      throw new Error(
+        `Unknown provider: ${providerName}. Use: minimax, elevenlabs, openai, or google`
+      );
+  }
+}
+
+// Display help information
+function showHelp(): void {
+  console.log(`
+Audio Generation CLI - Generate high-quality audio using AI
+
+USAGE:
+  bun run src/index.ts <command> [options]
+
+COMMANDS:
+  generate    Generate audio from text
+  voices      List available voices for a provider
+  help        Show this help message
+
+GENERATE OPTIONS:
+  --provider <name>     Provider to use: elevenlabs, openai, google (required)
+  --text <text>         Text to convert to speech (required)
+  --voice <voice>       Voice to use (optional, provider-specific)
+  --model <model>       Model to use (optional, provider-specific)
+  --output <path>       Output file path (required, e.g., ./output.mp3)
+  --language <code>     Language code (optional, for Google TTS, e.g., en-US)
+  --speed <number>      Speaking speed (optional, 0.25-4.0, default: 1.0)
+
+VOICES OPTIONS:
+  --provider <name>     Provider to list voices from (required)
+
+EXAMPLES:
+  # Generate audio with ElevenLabs
+  bun run src/index.ts generate --provider elevenlabs --text "Hello world" --voice rachel --output ./output.mp3
+
+  # Generate audio with OpenAI TTS
+  bun run src/index.ts generate --provider openai --text "Hello world" --voice nova --output ./output.mp3
+
+  # Generate audio with Google TTS
+  bun run src/index.ts generate --provider google --text "Hello world" --language en-US --output ./output.mp3
+
+  # List available voices
+  bun run src/index.ts voices --provider elevenlabs
+  bun run src/index.ts voices --provider openai
+  bun run src/index.ts voices --provider google
+
+ENVIRONMENT VARIABLES:
+  ELEVENLABS_API_KEY    API key for ElevenLabs
+  OPENAI_API_KEY        API key for OpenAI
+  GOOGLE_API_KEY        API key for Google Cloud TTS
+`);
+}
+
+// Main CLI handler
+async function main(): Promise<void> {
+  const args = parseArgs();
+
+  try {
+    switch (args.command) {
+      case 'generate': {
+        if (!args.provider) {
+          console.error('Error: --provider is required');
+          console.error('Use: bun run src/index.ts help');
+          process.exit(1);
+        }
+        if (!args.text) {
+          console.error('Error: --text is required');
+          console.error('Use: bun run src/index.ts help');
+          process.exit(1);
+        }
+        if (!args.output) {
+          console.error('Error: --output is required');
+          console.error('Use: bun run src/index.ts help');
+          process.exit(1);
+        }
+
+        const provider = getProvider(args.provider as Provider);
+        console.log(`Generating audio with ${provider.name}...`);
+
+        await provider.generate({
+          text: args.text,
+          voice: args.voice,
+          model: args.model,
+          output: args.output,
+          language: args.language,
+          speed: args.speed,
+        });
+        break;
+      }
+
+      case 'voices': {
+        if (!args.provider) {
+          console.error('Error: --provider is required');
+          console.error('Use: bun run src/index.ts help');
+          process.exit(1);
+        }
+
+        const provider = getProvider(args.provider as Provider);
+        console.log(`Fetching voices from ${provider.name}...\n`);
+
+        const voices = await provider.listVoices();
+
+        if (voices.length === 0) {
+          console.log('No voices available');
+          break;
+        }
+
+        console.log(`Found ${voices.length} voices:\n`);
+        voices.forEach((voice) => {
+          console.log(`  ${voice.name} (${voice.id})`);
+          if (voice.description) {
+            console.log(`    ${voice.description}`);
+          }
+          if (voice.category) {
+            console.log(`    Category: ${voice.category}`);
+          }
+          console.log('');
+        });
+        break;
+      }
+
+      case 'help':
+        showHelp();
+        break;
+
+      default:
+        console.error(`Unknown command: ${args.command}`);
+        console.error('Use: bun run src/index.ts help');
+        process.exit(1);
+    }
+  } catch (error) {
+    console.error('Error:', error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+// Run the CLI
+main();

package/skills/audio/src/index.ts

@@ -0,0 +1,95 @@
+#!/usr/bin/env bun
+
+import { executeAndSave, executeSkill, handleInstallCommand } from "../../_common";
+
+const SKILL = "audio";
+
+const SKILL_META = {
+  name: "audio",
+  description: "Generate speech and audio using provider-cost AI backends",
+  version: "1.0.0",
+  commands: "audio generate --provider <provider> --text <text> --output <file>",
+  requiredEnvVars: ["SKILL_API_KEY"],
+};
+
+if (await handleInstallCommand(SKILL_META, process.argv.slice(2))) {
+  process.exit(0);
+}
+
+function parseArgs(): Record<string, string | boolean> {
+  const parsed: Record<string, string | boolean> = {};
+  const args = process.argv.slice(2);
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const next = args[i + 1];
+      if (next && !next.startsWith("--")) {
+        parsed[key] = next;
+        i++;
+      } else {
+        parsed[key] = true;
+      }
+    } else if (!parsed.command) {
+      parsed.command = arg;
+    }
+  }
+  return parsed;
+}
+
+function printHelp() {
+  console.log(`Skill Audio CLI
+
+USAGE:
+  audio generate --provider <provider> --text <text> [options]
+
+PROVIDERS:
+  openai    tts-1, tts-1-hd
+  minimax   speech-2.8-turbo, speech-2.8-hd
+  gemini    gemini-2.5-flash-preview-tts, gemini-2.5-pro-preview-tts
+
+OPTIONS:
+  --model <model>    Provider model override
+  --text <text>      Text to synthesize
+  --voice <voice>    Provider-specific voice
+  --format <format>  mp3, wav, or opus
+  --output <path>    Save generated audio
+
+EXAMPLES:
+  audio generate --provider openai --text "Welcome to Skills.md" --voice alloy --output ./voice.mp3
+  audio generate --provider minimax --text "Fast narration" --output ./voice.mp3`);
+}
+
+async function main() {
+  const args = parseArgs();
+  const command = (args.command as string) || "help";
+
+  if (command === "help" || args.help) {
+    printHelp();
+    return;
+  }
+
+  const { command: _command, ...params } = args;
+  if (params.output) {
+    const success = await executeAndSave({ skill: SKILL, command, ...params });
+    process.exit(success ? 0 : 1);
+  }
+
+  const result = await executeSkill({ skill: SKILL, command, ...params });
+  if (result instanceof Blob) {
+    console.error("Unexpected binary response. Pass --output to save audio output.");
+    process.exit(1);
+  }
+  if (result.success && result.output) {
+    console.log(result.output);
+    return;
+  }
+  console.error(`Error: ${result.error || "Audio generation failed"}`);
+  if (result.details) console.error(result.details);
+  process.exit(1);
+}
+
+main().catch((error) => {
+  console.error(`Fatal error: ${(error as Error).message}`);
+  process.exit(1);
+});

package/skills/audio-cleanup-lab/CLAUDE.md

@@ -0,0 +1,3 @@
+# audio-cleanup-lab
+
+Professional audio cleanup recipes. Provides structured workflows for cleaning up audio files using various processing techniques.

package/skills/audio-cleanup-lab/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "audio-cleanup-lab",
+  "version": "0.1.0",
+  "type": "module",
+  "bin": {
+    "audio-cleanup-lab": "./src/index.ts"
+  },
+  "scripts": {
+    "dev": "bun run src/index.ts",
+    "build": "bun build src/index.ts --outdir dist --target bun",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {},
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "restricted"
+  },
+  "files": [
+    "src",
+    "dist",
+    "SKILL.md"
+  ]
+}