@hasna/skills 0.0.2

package/skills/skill-videodownload/src/lib/storage.ts

@@ -0,0 +1,167 @@
+/**
+ * Local storage for configuration and downloads
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, statSync } from "fs";
+import { join } from "path";
+import { getDataDir, getConfigPath, getDownloadsDir } from "../utils/paths.js";
+import type { Config, DownloadResult } from "../types/index.js";
+
+const DEFAULT_CONFIG: Config = {
+  outputDir: getDownloadsDir(),
+  defaultFormat: "best",
+  defaultQuality: "best",
+  ytDlpPath: "yt-dlp",
+};
+
+/**
+ * Ensure data directory exists
+ */
+export function ensureDataDir(): void {
+  const dir = getDataDir();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+
+/**
+ * Load configuration
+ */
+export function loadConfig(): Config {
+  ensureDataDir();
+  const configPath = getConfigPath();
+
+  if (existsSync(configPath)) {
+    try {
+      const data = readFileSync(configPath, "utf-8");
+      return { ...DEFAULT_CONFIG, ...JSON.parse(data) };
+    } catch {
+      return DEFAULT_CONFIG;
+    }
+  }
+
+  return DEFAULT_CONFIG;
+}
+
+/**
+ * Save configuration
+ */
+export function saveConfig(config: Partial<Config>): void {
+  ensureDataDir();
+  const current = loadConfig();
+  const merged = { ...current, ...config };
+  writeFileSync(getConfigPath(), JSON.stringify(merged, null, 2));
+}
+
+/**
+ * Get config path (re-export)
+ */
+export { getConfigPath };
+
+/**
+ * Ensure output directory exists
+ */
+export function ensureOutputDir(subdir?: string): string {
+  const config = loadConfig();
+  const dir = subdir ? join(config.outputDir, subdir) : config.outputDir;
+
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+
+  return dir;
+}
+
+/**
+ * Save download history entry
+ */
+export function saveDownloadHistory(result: DownloadResult): void {
+  ensureDataDir();
+  const historyPath = join(getDataDir(), "history.json");
+
+  let history: DownloadResult[] = [];
+  if (existsSync(historyPath)) {
+    try {
+      history = JSON.parse(readFileSync(historyPath, "utf-8"));
+    } catch {
+      history = [];
+    }
+  }
+
+  history.unshift({
+    ...result,
+    // Add timestamp
+    ...({ downloadedAt: new Date().toISOString() } as any),
+  });
+
+  // Keep last 100 entries
+  history = history.slice(0, 100);
+
+  writeFileSync(historyPath, JSON.stringify(history, null, 2));
+}
+
+/**
+ * Load download history
+ */
+export function loadDownloadHistory(): DownloadResult[] {
+  const historyPath = join(getDataDir(), "history.json");
+
+  if (existsSync(historyPath)) {
+    try {
+      return JSON.parse(readFileSync(historyPath, "utf-8"));
+    } catch {
+      return [];
+    }
+  }
+
+  return [];
+}
+
+/**
+ * List downloaded files
+ */
+export function listDownloads(): { filename: string; size: number; modified: Date }[] {
+  const config = loadConfig();
+  const outputDir = config.outputDir;
+
+  if (!existsSync(outputDir)) {
+    return [];
+  }
+
+  const files: { filename: string; size: number; modified: Date }[] = [];
+
+  function scanDir(dir: string, prefix = ""): void {
+    const entries = readdirSync(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+
+      if (entry.isDirectory()) {
+        scanDir(fullPath, relativePath);
+      } else if (isVideoFile(entry.name)) {
+        const stats = statSync(fullPath);
+        files.push({
+          filename: relativePath,
+          size: stats.size,
+          modified: stats.mtime,
+        });
+      }
+    }
+  }
+
+  scanDir(outputDir);
+
+  // Sort by modified date, newest first
+  files.sort((a, b) => b.modified.getTime() - a.modified.getTime());
+
+  return files;
+}
+
+/**
+ * Check if file is a video
+ */
+function isVideoFile(filename: string): boolean {
+  const videoExtensions = [".mp4", ".mkv", ".webm", ".avi", ".mov", ".m4v", ".flv", ".wmv"];
+  return videoExtensions.some((ext) => filename.toLowerCase().endsWith(ext));
+}

package/skills/skill-videodownload/src/types/index.ts

@@ -0,0 +1,64 @@
+/**
+ * Types for video download service
+ */
+
+export interface DownloadOptions {
+  output: string;
+  format: string;
+  quality: string;
+  audioOnly: boolean;
+  subtitles: boolean;
+  thumbnail: boolean;
+  metadata: boolean;
+}
+
+export interface VideoInfo {
+  id: string;
+  url: string;
+  title: string;
+  description?: string;
+  duration?: number;
+  thumbnail?: string;
+  formats: VideoFormat[];
+  platform: string;
+  uploader?: string;
+  uploadDate?: string;
+  viewCount?: number;
+}
+
+export interface VideoFormat {
+  formatId: string;
+  ext: string;
+  quality: string;
+  filesize?: number;
+  vcodec?: string;
+  acodec?: string;
+  resolution?: string;
+  fps?: number;
+}
+
+export interface DownloadResult {
+  success: boolean;
+  videoId: string;
+  title: string;
+  filepath?: string;
+  format?: string;
+  filesize?: number;
+  duration?: number;
+  error?: string;
+}
+
+export interface BulkDownloadResult {
+  url: string;
+  videosFound: number;
+  videosDownloaded: number;
+  results: DownloadResult[];
+  errors: string[];
+}
+
+export interface Config {
+  outputDir: string;
+  defaultFormat: string;
+  defaultQuality: string;
+  ytDlpPath: string;
+}

package/skills/skill-videodownload/src/utils/logger.ts

@@ -0,0 +1,49 @@
+/**
+ * Logger utility with colored output
+ */
+
+import chalk from "chalk";
+
+export function info(message: string): void {
+  console.log(chalk.blue("ℹ"), message);
+}
+
+export function success(message: string): void {
+  console.log(chalk.green("✓"), message);
+}
+
+export function warn(message: string): void {
+  console.log(chalk.yellow("⚠"), message);
+}
+
+export function error(message: string): void {
+  console.log(chalk.red("✗"), message);
+}
+
+export function debug(message: string): void {
+  if (process.env.DEBUG) {
+    console.log(chalk.gray("⋯"), message);
+  }
+}
+
+export function progress(current: number, total: number, message: string): void {
+  const percent = Math.round((current / total) * 100);
+  const bar = "█".repeat(Math.floor(percent / 5)) + "░".repeat(20 - Math.floor(percent / 5));
+  process.stdout.write(`\r${chalk.cyan(bar)} ${percent}% ${message}`);
+  if (current === total) {
+    process.stdout.write("\n");
+  }
+}
+
+export function heading(message: string): void {
+  console.log();
+  console.log(chalk.bold.underline(message));
+  console.log();
+}
+
+export function table(rows: [string, string][]): void {
+  const maxKeyLen = Math.max(...rows.map(([k]) => k.length));
+  for (const [key, value] of rows) {
+    console.log(`  ${chalk.dim(key.padEnd(maxKeyLen))}  ${value}`);
+  }
+}

package/skills/skill-videodownload/src/utils/paths.ts

@@ -0,0 +1,94 @@
+/**
+ * Path utilities
+ */
+
+import { homedir } from "os";
+import { join } from "path";
+
+/**
+ * Get the base data directory
+ */
+export function getDataDir(): string {
+  return process.env.DATA_DIR || join(homedir(), ".service", "service-videodownload");
+}
+
+/**
+ * Get the downloads directory
+ */
+export function getDownloadsDir(): string {
+  return join(getDataDir(), "downloads");
+}
+
+/**
+ * Get config file path
+ */
+export function getConfigPath(): string {
+  return join(getDataDir(), "config.json");
+}
+
+/**
+ * Extract video ID from URL
+ */
+export function extractVideoId(url: string): string | null {
+  // YouTube
+  const ytMatch = url.match(/(?:youtube\.com\/watch\?v=|youtu\.be\/|youtube\.com\/embed\/)([a-zA-Z0-9_-]{11})/);
+  if (ytMatch) return ytMatch[1];
+
+  // Vimeo
+  const vimeoMatch = url.match(/vimeo\.com\/(\d+)/);
+  if (vimeoMatch) return vimeoMatch[1];
+
+  // TikTok
+  const tiktokMatch = url.match(/tiktok\.com\/@[^/]+\/video\/(\d+)/);
+  if (tiktokMatch) return tiktokMatch[1];
+
+  return null;
+}
+
+/**
+ * Detect platform from URL
+ */
+export function detectPlatform(url: string): string {
+  if (url.includes("youtube.com") || url.includes("youtu.be")) return "youtube";
+  if (url.includes("vimeo.com")) return "vimeo";
+  if (url.includes("tiktok.com")) return "tiktok";
+  if (url.includes("twitter.com") || url.includes("x.com")) return "twitter";
+  if (url.includes("facebook.com") || url.includes("fb.watch")) return "facebook";
+  if (url.includes("instagram.com")) return "instagram";
+  if (url.includes("twitch.tv")) return "twitch";
+  return "generic";
+}
+
+/**
+ * Sanitize filename
+ */
+export function sanitizeFilename(name: string): string {
+  return name
+    .replace(/[<>:"/\\|?*]/g, "_")
+    .replace(/\s+/g, "_")
+    .substring(0, 200);
+}
+
+/**
+ * Format duration in seconds to HH:MM:SS
+ */
+export function formatDuration(seconds: number): string {
+  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 file size
+ */
+export function formatSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}

package/skills/skill-videodownload/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": ".",
+    "types": ["bun-types"],
+    "lib": ["ES2022"],
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*", "bin/**/*"],
+  "exclude": ["node_modules", "dist", "legacy"]
+}

package/skills/skill-voiceover/.env.example

@@ -0,0 +1,5 @@
+# OpenAI API key
+OPENAI_API_KEY=sk-your-api-key-here
+
+# ElevenLabs API key
+ELEVENLABS_API_KEY=your-elevenlabs-api-key-here

package/skills/skill-voiceover/CLAUDE.md

@@ -0,0 +1,40 @@
+# service-voiceovergenerate
+
+Generate voiceovers using ElevenLabs and OpenAI TTS.
+
+## Tech Stack
+
+- Runtime: Bun
+- Language: TypeScript
+- CLI: Commander.js
+- AI: OpenAI TTS, ElevenLabs API
+
+## Project Structure
+
+```
+├── bin/cli.ts
+├── src/
+│   ├── commands/
+│   │   ├── generate.ts
+│   │   ├── voices.ts
+│   │   └── config.ts
+│   ├── lib/
+│   │   ├── generator.ts
+│   │   └── storage.ts
+│   ├── types/index.ts
+│   └── utils/
+├── legacy/
+└── package.json
+```
+
+## CLI
+
+```bash
+service-voiceovergenerate generate "Hello" -p openai -v alloy
+service-voiceovergenerate voices elevenlabs
+```
+
+## Environment
+
+- `OPENAI_API_KEY` - For OpenAI TTS
+- `ELEVENLABS_API_KEY` - For ElevenLabs

package/skills/skill-voiceover/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Hasna
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/skills/skill-voiceover/README.md

@@ -0,0 +1,64 @@
+# service-voiceovergenerate
+
+Generate voiceovers using ElevenLabs and OpenAI TTS.
+
+## Installation
+
+```bash
+bun install -g @hasnaxyz/service-voiceovergenerate
+```
+
+## Quick Start
+
+```bash
+# Using OpenAI
+export OPENAI_API_KEY=sk-...
+service-voiceovergenerate generate "Hello world" -v alloy
+
+# Using ElevenLabs
+export ELEVENLABS_API_KEY=...
+service-voiceovergenerate generate "Hello world" -p elevenlabs -v 21m00Tcm4TlvDq8ikWAM
+
+# List voices
+service-voiceovergenerate voices openai
+service-voiceovergenerate voices elevenlabs
+```
+
+## CLI Commands
+
+### generate
+
+```bash
+service-voiceovergenerate generate <text> [options]
+
+Options:
+  -p, --provider <provider>  openai or elevenlabs (default: openai)
+  -v, --voice <voice>        Voice ID (default: alloy)
+  -s, --speed <speed>        Speed 0.25-4.0 (OpenAI only)
+  --stability <value>        Stability 0-1 (ElevenLabs)
+  --similarity <value>       Similarity 0-1 (ElevenLabs)
+```
+
+### voices
+
+```bash
+service-voiceovergenerate voices [provider]
+```
+
+### config
+
+```bash
+service-voiceovergenerate config view
+service-voiceovergenerate config set defaultProvider elevenlabs
+```
+
+## Environment Variables
+
+```bash
+OPENAI_API_KEY=sk-...           # For OpenAI TTS
+ELEVENLABS_API_KEY=...          # For ElevenLabs
+```
+
+## License
+
+MIT

package/skills/skill-voiceover/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@hasnaxyz/skill-voiceovergenerate",
+  "version": "0.1.0",
+  "description": "Generate voiceovers using ElevenLabs and OpenAI TTS",
+  "type": "module",
+  "bin": {
+    "skill-voiceovergenerate": "./bin/cli.ts",
+    "voiceover": "./bin/cli.ts"
+  },
+  "scripts": {
+    "dev": "bun run bin/cli.ts",
+    "build": "bun build bin/cli.ts --outdir dist --target node",
+    "typecheck": "tsc --noEmit"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hasnaxyz/skill-voiceovergenerate.git"
+  },
+  "author": "Hasna",
+  "license": "MIT",
+  "keywords": [
+    "voiceover",
+    "tts",
+    "text-to-speech",
+    "elevenlabs",
+    "openai",
+    "audio"
+  ],
+  "files": ["bin", "src", "tsconfig.json"],
+  "dependencies": {
+    "chalk": "^5.4.1",
+    "commander": "^13.0.0",
+    "openai": "^4.77.0"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.1.0",
+    "typescript": "^5.7.0"
+  },
+  "publishConfig": {
+    "access": "restricted",
+    "registry": "https://registry.npmjs.org/"
+  }
+}

package/skills/skill-voiceover/src/commands/config.ts

@@ -0,0 +1,38 @@
+import type { Command } from "commander";
+import chalk from "chalk";
+import { loadConfig, saveConfig, getConfigPath } from "../lib/storage.js";
+import * as logger from "../utils/logger.js";
+
+export function registerConfigCommand(program: Command): void {
+  const configCmd = program.command("config").description("View and edit configuration");
+
+  configCmd
+    .command("view")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const config = loadConfig();
+      const hasOpenAI = !!process.env.OPENAI_API_KEY;
+      const hasElevenLabs = !!(config.elevenLabsApiKey || process.env.ELEVENLABS_API_KEY);
+
+      if (options.json) {
+        console.log(JSON.stringify({ ...config, hasOpenAI, hasElevenLabs }, null, 2));
+        return;
+      }
+
+      logger.heading("Configuration");
+      logger.table([
+        ["Output directory", config.outputDir],
+        ["Default provider", config.defaultProvider],
+        ["Default voice", config.defaultVoice],
+        ["OpenAI API key", hasOpenAI ? chalk.green("configured") : chalk.red("not set")],
+        ["ElevenLabs API key", hasElevenLabs ? chalk.green("configured") : chalk.red("not set")],
+      ]);
+    });
+
+  configCmd
+    .command("set <key> <value>")
+    .action((key: string, value: string) => {
+      saveConfig({ [key]: value });
+      logger.success(`Set ${key} = ${key.includes("Key") ? "***" : value}`);
+    });
+}

package/skills/skill-voiceover/src/commands/generate.ts

@@ -0,0 +1,37 @@
+import type { Command } from "commander";
+import { generateVoiceover } from "../lib/generator.js";
+import * as logger from "../utils/logger.js";
+
+export function registerGenerateCommand(program: Command): void {
+  program
+    .command("generate <text>")
+    .alias("g")
+    .description("Generate voiceover from text")
+    .option("-p, --provider <provider>", "Provider: openai, elevenlabs", "openai")
+    .option("-v, --voice <voice>", "Voice ID or name", "alloy")
+    .option("-s, --speed <speed>", "Speed (OpenAI only, 0.25-4.0)", "1.0")
+    .option("--stability <value>", "Stability (ElevenLabs, 0-1)", "0.5")
+    .option("--similarity <value>", "Similarity boost (ElevenLabs, 0-1)", "0.75")
+    .action(async (text: string, options) => {
+      try {
+        const result = await generateVoiceover(text, {
+          provider: options.provider,
+          voice: options.voice,
+          speed: parseFloat(options.speed),
+          stability: parseFloat(options.stability),
+          similarityBoost: parseFloat(options.similarity),
+        });
+
+        logger.heading("Voiceover Generated");
+        logger.table([
+          ["File", result.filepath],
+          ["Provider", result.provider],
+          ["Voice", result.voice],
+          ["Format", result.format],
+        ]);
+      } catch (err) {
+        logger.error(`Generation failed: ${err}`);
+        process.exit(1);
+      }
+    });
+}

package/skills/skill-voiceover/src/commands/voices.ts

@@ -0,0 +1,33 @@
+import type { Command } from "commander";
+import chalk from "chalk";
+import { listVoices } from "../lib/generator.js";
+import * as logger from "../utils/logger.js";
+
+export function registerVoicesCommand(program: Command): void {
+  program
+    .command("voices [provider]")
+    .description("List available voices")
+    .option("--json", "Output as JSON")
+    .action(async (provider: string = "openai", options) => {
+      try {
+        const voices = await listVoices(provider as any);
+
+        if (options.json) {
+          console.log(JSON.stringify(voices, null, 2));
+          return;
+        }
+
+        logger.heading(`${provider} Voices`);
+
+        for (const voice of voices) {
+          console.log(`  ${chalk.cyan(voice.id.padEnd(30))} ${voice.name}`);
+        }
+
+        console.log();
+        logger.info(`${voices.length} voice(s) available`);
+      } catch (err) {
+        logger.error(`Failed to list voices: ${err}`);
+        process.exit(1);
+      }
+    });
+}