@hasna/skills 0.1.32 → 0.1.34

package/skills/domainpurchase/src/lib/config.ts

@@ -1,209 +0,0 @@
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
-
-export interface Config {
-  apiKey?: string;
-  apiSecret?: string;
-  customerId?: string;
-  shopperId?: string;
-  apiUrl: string;
-  // Remote server configuration
-  useRemoteServer?: boolean;
-  remoteServerUrl: string;
-  remoteApiKey?: string;
-}
-
-const CONFIG_DIR = join(homedir(), ".config", "service-domainpurchase");
-export const CONFIG_FILE = join(CONFIG_DIR, "config.json");
-const AWS_SECRET_NAME = process.env.AWS_SECRET_NAME || "your-org/your-tool/api/live";
-
-const DEFAULT_CONFIG: Config = {
-  apiUrl: "https://api.godaddy.com",
-  remoteServerUrl: process.env.DOMAIN_REMOTE_SERVER_URL || "https://service.example.com/domainpurchase",
-  useRemoteServer: false,
-};
-
-// Cache for AWS secrets to avoid repeated API calls
-let awsSecretsCache: Partial<Config> | null = null;
-
-async function loadAwsSecrets(): Promise<Partial<Config>> {
-  if (awsSecretsCache) {
-    return awsSecretsCache;
-  }
-
-  try {
-    const { SecretsManagerClient, GetSecretValueCommand } = await import(
-      "@aws-sdk/client-secrets-manager"
-    );
-    const client = new SecretsManagerClient({ region: "us-east-1" });
-    const response = await client.send(
-      new GetSecretValueCommand({ SecretId: AWS_SECRET_NAME })
-    );
-
-    if (response.SecretString) {
-      const secret = JSON.parse(response.SecretString);
-      awsSecretsCache = {
-        apiKey: secret.api_key,
-        apiSecret: secret.api_secret,
-        customerId: secret.customer_id,
-        shopperId: secret.shopper_id,
-      };
-      return awsSecretsCache;
-    }
-  } catch {
-    // AWS secrets not available, fall back to other sources
-  }
-
-  return {};
-}
-
-export function loadConfig(): Config {
-  // First check environment variables
-  const envConfig: Partial<Config> = {
-    apiKey: process.env.DOMAIN_API_KEY,
-    apiSecret: process.env.DOMAIN_API_SECRET,
-    customerId: process.env.DOMAIN_CUSTOMER_ID,
-    apiUrl: process.env.DOMAIN_API_URL,
-  };
-
-  // Then load from config file
-  let fileConfig: Partial<Config> = {};
-  if (existsSync(CONFIG_FILE)) {
-    try {
-      fileConfig = JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
-    } catch {
-      // Ignore parse errors
-    }
-  }
-
-  // Merge with defaults (env vars take priority)
-  return {
-    ...DEFAULT_CONFIG,
-    ...fileConfig,
-    ...Object.fromEntries(
-      Object.entries(envConfig).filter(([_, v]) => v !== undefined)
-    ),
-  };
-}
-
-export async function loadConfigAsync(): Promise<Config> {
-  // Load AWS secrets first (lowest priority)
-  const awsConfig = await loadAwsSecrets();
-
-  // Then check environment variables
-  const envConfig: Partial<Config> = {
-    apiKey: process.env.DOMAIN_API_KEY,
-    apiSecret: process.env.DOMAIN_API_SECRET,
-    customerId: process.env.DOMAIN_CUSTOMER_ID,
-    apiUrl: process.env.DOMAIN_API_URL,
-    useRemoteServer: process.env.DOMAIN_USE_REMOTE_SERVER === "true",
-    remoteServerUrl: process.env.DOMAIN_REMOTE_SERVER_URL,
-    remoteApiKey: process.env.DOMAIN_REMOTE_API_KEY,
-  };
-
-  // Then load from config file
-  let fileConfig: Partial<Config> = {};
-  if (existsSync(CONFIG_FILE)) {
-    try {
-      fileConfig = JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
-    } catch {
-      // Ignore parse errors
-    }
-  }
-
-  // Merge: AWS -> file -> env (env takes highest priority)
-  return {
-    ...DEFAULT_CONFIG,
-    ...awsConfig,
-    ...fileConfig,
-    ...Object.fromEntries(
-      Object.entries(envConfig).filter(([_, v]) => v !== undefined)
-    ),
-  };
-}
-
-export function saveConfig(config: Partial<Config>): void {
-  if (!existsSync(CONFIG_DIR)) {
-    mkdirSync(CONFIG_DIR, { recursive: true });
-  }
-
-  const current = loadConfig();
-  const merged = { ...current, ...config };
-  writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2));
-}
-
-export function getApiKey(): string | undefined {
-  return loadConfig().apiKey;
-}
-
-export function getApiSecret(): string | undefined {
-  return loadConfig().apiSecret;
-}
-
-export function getCustomerId(): string | undefined {
-  return loadConfig().customerId;
-}
-
-export function getApiUrl(): string {
-  return loadConfig().apiUrl;
-}
-
-// Async versions that can load from AWS Secrets Manager
-export async function getApiKeyAsync(): Promise<string | undefined> {
-  return (await loadConfigAsync()).apiKey;
-}
-
-export async function getApiSecretAsync(): Promise<string | undefined> {
-  return (await loadConfigAsync()).apiSecret;
-}
-
-export async function getCustomerIdAsync(): Promise<string | undefined> {
-  return (await loadConfigAsync()).customerId;
-}
-
-export async function getShopperIdAsync(): Promise<string | undefined> {
-  return (await loadConfigAsync()).shopperId;
-}
-
-export async function getApiUrlAsync(): Promise<string> {
-  return (await loadConfigAsync()).apiUrl;
-}
-
-// Remote server configuration getters
-export function useRemoteServer(): boolean {
-  return loadConfig().useRemoteServer || false;
-}
-
-export function getRemoteServerUrl(): string {
-  return loadConfig().remoteServerUrl;
-}
-
-export function getRemoteApiKey(): string | undefined {
-  return loadConfig().remoteApiKey;
-}
-
-export async function getRemoteApiKeyAsync(): Promise<string | undefined> {
-  const config = await loadConfigAsync();
-  if (config.remoteApiKey) {
-    return config.remoteApiKey;
-  }
-  // Try to load from AWS Secrets Manager
-  try {
-    const { SecretsManagerClient, GetSecretValueCommand } = await import(
-      "@aws-sdk/client-secrets-manager"
-    );
-    const client = new SecretsManagerClient({ region: "us-east-1" });
-    const response = await client.send(
-      new GetSecretValueCommand({ SecretId: process.env.DOMAIN_API_KEY_SECRET_ID || "your-org/prod/your-service/api-key" })
-    );
-    return response.SecretString;
-  } catch {
-    return undefined;
-  }
-}
-
-// Initialize config from AWS on first run
-export async function initConfig(): Promise<void> {
-  await loadConfigAsync();
-}

package/skills/domainpurchase/src/lib/installer.ts

@@ -1,165 +0,0 @@
-import { existsSync, mkdirSync, writeFileSync, appendFileSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
-
-const SERVICE_NAME = "service-domainpurchase";
-const SERVICE_DIR_NAME = `.${SERVICE_NAME}`;
-
-export interface InstallOptions {
-  force?: boolean;
-}
-
-export function getServiceDir(): string {
-  return join(homedir(), SERVICE_DIR_NAME);
-}
-
-export function getLogFilePath(): string {
-  return join(getServiceDir(), `${SERVICE_NAME}.log`);
-}
-
-export function getReadmePath(): string {
-  return join(getServiceDir(), "README.md");
-}
-
-export function isInstalled(): boolean {
-  return existsSync(getServiceDir());
-}
-
-export function ensureInstalled(): void {
-  if (!isInstalled()) {
-    install();
-  }
-}
-
-export function install(options: InstallOptions = {}): { success: boolean; path: string; message: string } {
-  const serviceDir = getServiceDir();
-
-  if (existsSync(serviceDir) && !options.force) {
-    return {
-      success: false,
-      path: serviceDir,
-      message: "Already installed. Use --force to reinstall.",
-    };
-  }
-
-  mkdirSync(serviceDir, { recursive: true });
-
-  const readmeContent = generateReadme();
-  writeFileSync(getReadmePath(), readmeContent);
-
-  const logHeader = `# ${SERVICE_NAME} log file
-# Created: ${new Date().toISOString()}
-# This file contains activity history and logs.
-# -------------------------------------------------------
-
-`;
-  writeFileSync(getLogFilePath(), logHeader);
-
-  return {
-    success: true,
-    path: serviceDir,
-    message: `Installed at ${serviceDir}`,
-  };
-}
-
-export function uninstall(): { success: boolean; message: string } {
-  const serviceDir = getServiceDir();
-
-  if (!existsSync(serviceDir)) {
-    return {
-      success: false,
-      message: "Not installed.",
-    };
-  }
-
-  const { rmSync } = require("fs");
-  rmSync(serviceDir, { recursive: true, force: true });
-
-  return {
-    success: true,
-    message: `Uninstalled from ${serviceDir}`,
-  };
-}
-
-function generateReadme(): string {
-  return `# .${SERVICE_NAME}
-
-This directory contains local configuration and logs for \`${SERVICE_NAME}\`.
-
-## Files
-
-| Path | Description |
-|------|-------------|
-| \`${SERVICE_NAME}.log\` | Activity log |
-| \`README.md\` | This file |
-
-## What is ${SERVICE_NAME}?
-
-\`${SERVICE_NAME}\` is a domain purchase service that provides:
-
-- Domain registration automation
-- Registrar integrations (GoDaddy, Namecheap, etc.)
-- DNS configuration
-- Domain transfer management
-- Renewal tracking
-
-## Usage
-
-\`\`\`bash
-# Purchase a domain
-service-domainpurchase buy --domain "example.com"
-
-# List purchased domains
-service-domainpurchase list
-
-# Check purchase status
-service-domainpurchase status --domain "example.com"
-
-# Start the server
-service-domainpurchase server
-\`\`\`
-
-## Log File
-
-The \`${SERVICE_NAME}.log\` file contains:
-- Purchase transactions
-- Registration status
-- DNS changes
-- API activity
-
-## More Information
-
-For full documentation, run:
-
-\`\`\`bash
-service-domainpurchase --help
-\`\`\`
-`;
-}
-
-export type LogLevel = "debug" | "info" | "warn" | "error";
-
-export function logToFile(message: string, level: LogLevel = "info"): void {
-  ensureInstalled();
-
-  const timestamp = new Date().toISOString();
-  const logLine = `[${timestamp}] [${level.toUpperCase()}] ${message}\n`;
-
-  try {
-    appendFileSync(getLogFilePath(), logLine);
-  } catch {
-    // Silently fail
-  }
-}
-
-export function logInfo(message: string): void {
-  logToFile(message, "info");
-}
-
-export function logError(message: string): void {
-  logToFile(message, "error");
-}
-
-export function logWarn(message: string): void {
-  logToFile(message, "warn");
-}

package/skills/image/.env.example

@@ -1,12 +0,0 @@
-# OpenAI API Key
-# Get your key from: https://platform.openai.com/api-keys
-OPENAI_API_KEY=sk-...
-
-# Google Gemini API Key and Project ID
-# Get your key from: https://aistudio.google.com/apikey
-GEMINI_API_KEY=...
-GOOGLE_PROJECT_ID=your-project-id
-
-# xAI API Key
-# Get your key from: https://x.ai/api
-XAI_API_KEY=...

package/skills/image/PROJECT_OVERVIEW.md

@@ -1,216 +0,0 @@
-# Image Generation Skill - Project Overview
-
-## Summary
-
-A complete Claude Code skill for AI-powered image generation supporting three major providers: OpenAI DALL-E 3, Google Imagen 3, and xAI Aurora.
-
-## Key Statistics
-
-- **Total Lines of Code**: ~993 lines
-- **TypeScript Files**: 5 (457 lines)
-- **Providers**: 3 (OpenAI, Google, xAI)
-- **Documentation Files**: 5
-- **Example Scripts**: 3
-- **Dependencies**: Zero (uses native Bun APIs)
-
-## File Structure
-
-```
-image/
-├── SKILL.md              [56 lines]  - Skill metadata with YAML frontmatter
-├── README.md             [194 lines] - Comprehensive documentation
-├── QUICKSTART.md         [111 lines] - Quick start guide
-├── PROJECT_OVERVIEW.md   - This file
-├── package.json          [29 lines]  - Bun package configuration
-├── tsconfig.json         [17 lines]  - TypeScript configuration
-├── .env.example          [12 lines]  - Environment variable template
-├── .gitignore            [12 lines]  - Git ignore patterns
-├── examples/
-│   ├── openai-examples.sh    [35 lines] - OpenAI usage examples
-│   ├── google-examples.sh    [37 lines] - Google usage examples
-│   └── xai-examples.sh       [33 lines] - xAI usage examples
-└── src/
-    ├── index.ts          [189 lines] - Main CLI entry point
-    ├── types.ts          [37 lines]  - TypeScript type definitions
-    └── providers/
-        ├── openai.ts     [80 lines]  - OpenAI DALL-E provider
-        ├── google.ts     [78 lines]  - Google Imagen provider
-        └── xai.ts        [73 lines]  - xAI Aurora provider
-```
-
-## Features Implemented
-
-### Core Functionality
-- ✅ Multi-provider image generation (OpenAI, Google, xAI)
-- ✅ Clean CLI interface with argument parsing
-- ✅ Automatic image download and file saving
-- ✅ Support for custom models and sizes
-- ✅ Environment variable configuration
-- ✅ Comprehensive error handling
-
-### OpenAI Provider
-- ✅ DALL-E 3 support
-- ✅ GPT-4o image generation (gpt-image-1)
-- ✅ Three size options: 1024x1024, 1792x1024, 1024x1792
-- ✅ Revised prompt display
-- ✅ URL-based image retrieval
-
-### Google Imagen Provider
-- ✅ Imagen 3.0 support via Vertex AI REST API
-- ✅ Five aspect ratio options: 1:1, 3:4, 4:3, 9:16, 16:9
-- ✅ Base64 image decoding
-- ✅ Project ID configuration
-
-### xAI Aurora Provider
-- ✅ Aurora model support
-- ✅ OpenAI-compatible API format
-- ✅ Support for both URL and base64 responses
-- ✅ Flexible size configuration
-
-### Developer Experience
-- ✅ TypeScript with strict type checking
-- ✅ Native Bun runtime (no external dependencies)
-- ✅ Modular provider architecture
-- ✅ Clean separation of concerns
-- ✅ Comprehensive inline documentation
-- ✅ Example scripts for all providers
-
-### Error Handling
-- ✅ API key validation
-- ✅ Invalid provider detection
-- ✅ Missing argument detection
-- ✅ HTTP error handling
-- ✅ Network failure handling
-- ✅ Size validation (provider-specific)
-
-## Usage Examples
-
-### Basic Usage
-```bash
-bun run src/index.ts generate --provider openai --prompt "a cat" --output ./cat.png
-```
-
-### With Custom Options
-```bash
-bun run src/index.ts generate \
-  --provider openai \
-  --prompt "a futuristic city" \
-  --output ./city.png \
-  --size 1792x1024 \
-  --model dall-e-3
-```
-
-### Short Flags
-```bash
-bun run src/index.ts generate -p google --prompt "a dog" -o ./dog.png -s 16:9
-```
-
-## API Integration Details
-
-### OpenAI DALL-E 3
-- **Endpoint**: `https://api.openai.com/v1/images/generations`
-- **Authentication**: Bearer token via `Authorization` header
-- **Request Format**: JSON with model, prompt, size, response_format
-- **Response Format**: URL or base64
-- **Environment Variable**: `OPENAI_API_KEY`
-
-### Google Imagen 3
-- **Endpoint**: `https://{location}-aiplatform.googleapis.com/v1/projects/{projectId}/locations/{location}/publishers/google/models/{model}:predict`
-- **Authentication**: Bearer token via `Authorization` header
-- **Request Format**: JSON with instances and parameters
-- **Response Format**: Base64 encoded image
-- **Environment Variables**: `GOOGLE_API_KEY`, `GOOGLE_PROJECT_ID`
-
-### xAI Aurora
-- **Endpoint**: `https://api.x.ai/v1/images/generations`
-- **Authentication**: Bearer token via `Authorization` header
-- **Request Format**: OpenAI-compatible JSON
-- **Response Format**: URL or base64
-- **Environment Variable**: `XAI_API_KEY`
-
-## Architecture Patterns
-
-### Provider Interface
-All providers implement the `ImageProvider` interface:
-```typescript
-interface ImageProvider {
-  generate(prompt: string, options?: {
-    model?: string;
-    size?: string;
-  }): Promise<Buffer>;
-}
-```
-
-### Type Safety
-- Strong typing throughout the codebase
-- Provider-specific response interfaces
-- Validated command-line options
-- Type-safe error handling
-
-### Modularity
-- Each provider in separate file
-- Shared types in dedicated module
-- Clean CLI entry point
-- No circular dependencies
-
-## Testing Performed
-
-✅ Help command display
-✅ Invalid provider detection
-✅ Missing argument validation
-✅ Successful image generation (OpenAI)
-✅ File output and directory creation
-✅ TypeScript compilation
-✅ Bun runtime compatibility
-
-## Future Enhancement Possibilities
-
-- Image editing capabilities (inpainting, outpainting)
-- Batch generation support
-- Image variation generation
-- Progress bars for long-running operations
-- Local image storage caching
-- Configuration file support (JSON/YAML)
-- Additional providers (Stability AI, Midjourney API)
-- Image quality/resolution options
-- Rate limiting and retry logic
-- Cost estimation before generation
-
-## Technical Highlights
-
-1. **Zero Dependencies**: Uses only native Bun APIs (fetch, fs/promises)
-2. **Type-Safe**: Comprehensive TypeScript types for all operations
-3. **Clean Code**: Well-organized, readable, maintainable
-4. **Error Resilient**: Handles all common error scenarios gracefully
-5. **Extensible**: Easy to add new providers following existing pattern
-6. **Production Ready**: Includes all necessary error handling and validation
-
-## Quick Reference
-
-| Provider | Model | Default Size | Custom Sizes |
-|----------|-------|-------------|--------------|
-| OpenAI | dall-e-3 | 1024x1024 | 1792x1024, 1024x1792 |
-| Google | imagen-3.0-generate-001 | 1:1 | 3:4, 4:3, 9:16, 16:9 |
-| xAI | aurora | Default | Provider-specific |
-
-## Environment Setup
-
-```bash
-# OpenAI
-export OPENAI_API_KEY="sk-..."
-
-# Google
-export GOOGLE_API_KEY="..."
-export GOOGLE_PROJECT_ID="your-project"
-
-# xAI
-export XAI_API_KEY="..."
-```
-
-## License
-
-MIT
-
----
-
-Built with Bun, TypeScript, and Claude Code

package/skills/image/QUICKSTART.md

@@ -1,111 +0,0 @@
-# Quick Start Guide
-
-Get started with the Image Generation Skill in 3 easy steps.
-
-## Step 1: Set up API Keys
-
-Copy the example environment file and add your API keys:
-
-```bash
-cp .env.example .env
-# Edit .env with your favorite editor and add your API keys
-```
-
-Or export them directly:
-
-```bash
-export OPENAI_API_KEY="sk-..."
-export GEMINI_API_KEY="..."
-export GOOGLE_PROJECT_ID="your-project-id"
-export XAI_API_KEY="..."
-```
-
-## Step 2: Generate Your First Image
-
-Choose a provider and run:
-
-```bash
-# OpenAI
-bun run src/index.ts generate \
-  --provider openai \
-  --prompt "a beautiful sunset over mountains" \
-  --output ./my-first-image.png
-
-# Google
-bun run src/index.ts generate \
-  --provider google \
-  --prompt "a beautiful sunset over mountains" \
-  --output ./my-first-image.png
-
-# xAI
-bun run src/index.ts generate \
-  --provider xai \
-  --prompt "a beautiful sunset over mountains" \
-  --output ./my-first-image.png
-```
-
-## Step 3: Explore Advanced Options
-
-### Custom Sizes
-
-OpenAI sizes:
-```bash
-bun run src/index.ts generate \
-  -p openai \
-  --prompt "wide landscape" \
-  -o ./landscape.png \
-  --size 1792x1024
-```
-
-Google aspect ratios:
-```bash
-bun run src/index.ts generate \
-  -p google \
-  --prompt "portrait photo" \
-  -o ./portrait.png \
-  --size 3:4
-```
-
-### Run Example Scripts
-
-```bash
-cd examples
-./openai-examples.sh
-./google-examples.sh
-./xai-examples.sh
-```
-
-## Tips
-
-1. **Prompt Engineering**: Be specific and descriptive in your prompts
-2. **Size Selection**: Choose the right size for your use case
-   - Square (1024x1024, 1:1): Social media posts, avatars
-   - Landscape (1792x1024, 16:9): Banners, headers
-   - Portrait (1024x1792, 9:16): Mobile wallpapers, stories
-3. **Provider Selection**:
-   - OpenAI: Great for detailed, creative images
-   - Google: Best for photorealistic results
-   - xAI: Excellent for artistic interpretation
-
-## Troubleshooting
-
-### "API key required" error
-Make sure your environment variables are set correctly.
-
-### "Invalid size" error
-Check the provider-specific size options in the help:
-```bash
-bun run src/index.ts --help
-```
-
-### Image quality issues
-Try being more specific in your prompt or experiment with different providers.
-
-## Next Steps
-
-- Read the full [README.md](README.md) for detailed documentation
-- Check [SKILL.md](SKILL.md) for skill metadata
-- Explore the [examples/](examples/) directory for more use cases
-- Review [src/](src/) for implementation details
-
-Happy image generation!