@hasna/skills 0.0.2

package/skills/skill-download/src/installer.ts

@@ -0,0 +1,324 @@
+#!/usr/bin/env bun
+
+/**
+ * Skill Installer Module
+ *
+ * Universal installer for skills to integrate with AI code assistants
+ * Usage: skill-[name] install [claude|codex|windsurf|cursor]
+ */
+
+import { writeFileSync, mkdirSync, existsSync, readFileSync } from 'fs';
+import { resolve, join } from 'path';
+import { homedir } from 'os';
+
+export interface SkillConfig {
+  name: string;
+  description: string;
+  version: string;
+  commands: Array<{
+    name: string;
+    description: string;
+    usage: string;
+    examples: string[];
+  }>;
+  requiredEnvVars?: string[];
+  optionalEnvVars?: string[];
+}
+
+export type AssistantType = 'claude' | 'codex' | 'windsurf' | 'cursor';
+
+const ASSISTANT_PATHS: Record<AssistantType, string> = {
+  claude: '.claude/skills',
+  codex: '.codex/skills',
+  windsurf: '.windsurf/skills',
+  cursor: '.cursor/skills',
+};
+
+export class SkillInstaller {
+  private config: SkillConfig;
+  private skillPath: string;
+
+  constructor(config: SkillConfig, currentFilePath: string) {
+    this.config = config;
+    // Get the root directory of the skill (where package.json is)
+    this.skillPath = resolve(currentFilePath, '..');
+  }
+
+  /**
+   * Install the skill to specified AI assistant
+   */
+  async install(assistant: AssistantType): Promise<void> {
+    console.log(`📦 Installing ${this.config.name} for ${assistant}...`);
+    console.log('');
+
+    const assistantPath = ASSISTANT_PATHS[assistant];
+    if (!assistantPath) {
+      throw new Error(`Unknown assistant: ${assistant}`);
+    }
+
+    // Create skill directory
+    const skillDir = join(homedir(), assistantPath, this.config.name);
+    mkdirSync(skillDir, { recursive: true });
+    console.log(`✓ Created: ${skillDir}`);
+
+    // Generate and write SKILL.md
+    const skillMd = this.generateSkillMd();
+    writeFileSync(join(skillDir, 'SKILL.md'), skillMd);
+    console.log(`✓ Created: SKILL.md`);
+
+    // Generate and write README.md
+    const readme = this.generateReadme();
+    writeFileSync(join(skillDir, 'README.md'), readme);
+    console.log(`✓ Created: README.md`);
+
+    // Create log file
+    const logFile = join(skillDir, `${this.config.name}.log`);
+    if (!existsSync(logFile)) {
+      writeFileSync(logFile, `# ${this.config.name} execution log\n# Created: ${new Date().toISOString()}\n\n`);
+      console.log(`✓ Created: ${this.config.name}.log`);
+    }
+
+    // Update MCP config
+    this.updateMcpConfig(assistant, skillDir);
+
+    console.log('');
+    console.log(`✅ ${this.config.name} installed successfully!`);
+    console.log('');
+    console.log('Location:', skillDir);
+    console.log('');
+    console.log('Usage:');
+    this.config.commands.slice(0, 3).forEach(cmd => {
+      console.log(`  ${this.config.name} ${cmd.usage}`);
+    });
+  }
+
+  /**
+   * Generate SKILL.md documentation
+   */
+  private generateSkillMd(): string {
+    const envVarsSection = this.config.requiredEnvVars?.length || this.config.optionalEnvVars?.length ? `
+
+## Environment Variables
+
+${this.config.requiredEnvVars?.length ? `### Required
+${this.config.requiredEnvVars.map(v => `- \`${v}\``).join('\n')}
+` : ''}
+${this.config.optionalEnvVars?.length ? `### Optional
+${this.config.optionalEnvVars.map(v => `- \`${v}\``).join('\n')}
+` : ''}` : '';
+
+    return `# ${this.config.name}
+
+${this.config.description}
+
+## Version
+${this.config.version}
+
+## Commands
+
+${this.config.commands.map(cmd => `### ${cmd.name}
+
+${cmd.description}
+
+**Usage:**
+\`\`\`bash
+${this.config.name} ${cmd.usage}
+\`\`\`
+
+**Examples:**
+${cmd.examples.map(ex => `\`\`\`bash
+${ex}
+\`\`\``).join('\n')}
+`).join('\n')}
+${envVarsSection}
+
+## Installation
+
+This skill is installed at:
+\`~/.claude/skills/${this.config.name}/\`
+
+## Logs
+
+Execution logs are written to:
+\`~/.claude/skills/${this.config.name}/${this.config.name}.log\`
+
+## Support
+
+For issues, visit: https://github.com/hasnaxyz/${this.config.name}/issues
+`;
+  }
+
+  /**
+   * Generate README.md
+   */
+  private generateReadme(): string {
+    return `# ${this.config.name}
+
+${this.config.description}
+
+## Quick Start
+
+\`\`\`bash
+${this.config.commands[0] ? `${this.config.name} ${this.config.commands[0].usage}` : `${this.config.name} --help`}
+\`\`\`
+
+## Documentation
+
+See [SKILL.md](./SKILL.md) for complete documentation.
+
+## Version
+
+${this.config.version}
+`;
+  }
+
+  /**
+   * Update MCP config to register the skill
+   */
+  private updateMcpConfig(assistant: AssistantType, skillDir: string): void {
+    const configPaths: Record<AssistantType, string> = {
+      claude: join(homedir(), '.config/claude-code/claude_mcp_config.json'),
+      codex: join(homedir(), '.config/codex/mcp_config.json'),
+      windsurf: join(homedir(), '.config/windsurf/mcp_config.json'),
+      cursor: join(homedir(), '.config/cursor/mcp_config.json'),
+    };
+
+    const configPath = configPaths[assistant];
+
+    // Read existing config or create new
+    let config: any = { mcpServers: {} };
+    if (existsSync(configPath)) {
+      const content = readFileSync(configPath, 'utf8');
+      config = JSON.parse(content);
+    }
+
+    if (!config.mcpServers) {
+      config.mcpServers = {};
+    }
+
+    // Add or update this skill
+    config.mcpServers[this.config.name] = {
+      command: 'bun',
+      args: ['run', join(this.skillPath, 'src/index.ts')],
+      env: this.getEnvConfig(),
+    };
+
+    // Write config
+    mkdirSync(resolve(configPath, '..'), { recursive: true });
+    writeFileSync(configPath, JSON.stringify(config, null, 2));
+    console.log(`✓ Updated: ${assistant} MCP config`);
+  }
+
+  /**
+   * Get environment variables config
+   */
+  private getEnvConfig(): Record<string, string> {
+    const env: Record<string, string> = {
+      SKILL_API_KEY: process.env.SKILL_API_KEY || '',
+    };
+
+    // Add required env vars
+    this.config.requiredEnvVars?.forEach(key => {
+      env[key] = process.env[key] || '';
+    });
+
+    // Add optional env vars
+    this.config.optionalEnvVars?.forEach(key => {
+      env[key] = process.env[key] || '';
+    });
+
+    return env;
+  }
+
+  /**
+   * Uninstall the skill from specified AI assistant
+   */
+  async uninstall(assistant: AssistantType): Promise<void> {
+    console.log(`🗑️  Uninstalling ${this.config.name} from ${assistant}...`);
+    console.log('');
+
+    const assistantPath = ASSISTANT_PATHS[assistant];
+    const skillDir = join(homedir(), assistantPath, this.config.name);
+
+    if (existsSync(skillDir)) {
+      // Remove from MCP config first
+      this.removeFromMcpConfig(assistant);
+
+      // Note: We don't delete the directory to preserve logs and user data
+      console.log(`✓ Removed from ${assistant} MCP config`);
+      console.log('');
+      console.log(`⚠️  Directory preserved: ${skillDir}`);
+      console.log('   (contains logs and configuration)');
+      console.log('   Delete manually if needed.');
+    } else {
+      console.log(`⚠️  ${this.config.name} is not installed for ${assistant}`);
+    }
+  }
+
+  /**
+   * Remove skill from MCP config
+   */
+  private removeFromMcpConfig(assistant: AssistantType): void {
+    const configPaths: Record<AssistantType, string> = {
+      claude: join(homedir(), '.config/claude-code/claude_mcp_config.json'),
+      codex: join(homedir(), '.config/codex/mcp_config.json'),
+      windsurf: join(homedir(), '.config/windsurf/mcp_config.json'),
+      cursor: join(homedir(), '.config/cursor/mcp_config.json'),
+    };
+
+    const configPath = configPaths[assistant];
+
+    if (existsSync(configPath)) {
+      const content = readFileSync(configPath, 'utf8');
+      const config = JSON.parse(content);
+
+      if (config.mcpServers && config.mcpServers[this.config.name]) {
+        delete config.mcpServers[this.config.name];
+        writeFileSync(configPath, JSON.stringify(config, null, 2));
+      }
+    }
+  }
+}
+
+/**
+ * Helper to run installer from skill CLI
+ */
+export async function runInstaller(
+  config: SkillConfig,
+  currentFilePath: string,
+  args: string[]
+): Promise<void> {
+  const installer = new SkillInstaller(config, currentFilePath);
+
+  const command = args[0];
+  const assistant = args[1] as AssistantType;
+
+  if (command === 'install') {
+    if (!assistant || !['claude', 'codex', 'windsurf', 'cursor'].includes(assistant)) {
+      console.error('❌ Error: Please specify an assistant');
+      console.error('');
+      console.error('Usage:');
+      console.error(`  ${config.name} install [claude|codex|windsurf|cursor]`);
+      console.error('');
+      console.error('Examples:');
+      console.error(`  ${config.name} install claude`);
+      console.error(`  ${config.name} install codex`);
+      process.exit(1);
+    }
+
+    await installer.install(assistant);
+  } else if (command === 'uninstall') {
+    if (!assistant || !['claude', 'codex', 'windsurf', 'cursor'].includes(assistant)) {
+      console.error('❌ Error: Please specify an assistant');
+      console.error('');
+      console.error('Usage:');
+      console.error(`  ${config.name} uninstall [claude|codex|windsurf|cursor]`);
+      process.exit(1);
+    }
+
+    await installer.uninstall(assistant);
+  } else {
+    console.error(`❌ Unknown installer command: ${command}`);
+    process.exit(1);
+  }
+}

package/skills/skill-download/src/skill-install.ts

@@ -0,0 +1,205 @@
+/**
+ * Skill Installation Handler
+ *
+ * Add this code to your skill's index.ts to enable:
+ *   skill-[name] install claude
+ *   skill-[name] install codex
+ *   skill-[name] uninstall claude
+ */
+
+import { writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+interface SkillMeta {
+  name: string;
+  description: string;
+  version: string;
+  commands: string; // Help text or command list
+  requiredEnvVars?: string[];
+}
+
+export async function handleInstallCommand(meta: SkillMeta, args: string[]): Promise<boolean> {
+  const command = args[0];
+  const assistant = args[1];
+
+  if (command !== 'install' && command !== 'uninstall') {
+    return false; // Not an install command
+  }
+
+  if (!assistant || !['claude', 'codex', 'windsurf', 'cursor'].includes(assistant)) {
+    console.error('❌ Error: Please specify an assistant');
+    console.error('');
+    console.error('Usage:');
+    console.error(`  ${meta.name} install [claude|codex|windsurf|cursor]`);
+    console.error(`  ${meta.name} uninstall [claude|codex|windsurf|cursor]`);
+    console.error('');
+    console.error('Examples:');
+    console.error(`  ${meta.name} install claude`);
+    console.error(`  ${meta.name} install codex`);
+    process.exit(1);
+  }
+
+  if (command === 'install') {
+    await installSkill(meta, assistant);
+  } else {
+    await uninstallSkill(meta, assistant);
+  }
+
+  return true;
+}
+
+async function installSkill(meta: SkillMeta, assistant: string): Promise<void> {
+  console.log(`📦 Installing ${meta.name} for ${assistant}...`);
+  console.log('');
+
+  const assistantPaths: Record<string, string> = {
+    claude: '.claude/skills',
+    codex: '.codex/skills',
+    windsurf: '.windsurf/skills',
+    cursor: '.cursor/skills',
+  };
+
+  const skillDir = join(homedir(), assistantPaths[assistant], meta.name);
+  mkdirSync(skillDir, { recursive: true });
+  console.log(`✓ Created: ${skillDir}`);
+
+  // Generate SKILL.md
+  const skillMd = generateSkillMd(meta);
+  writeFileSync(join(skillDir, 'SKILL.md'), skillMd);
+  console.log(`✓ Created: SKILL.md`);
+
+  // Generate README.md
+  const readme = generateReadme(meta);
+  writeFileSync(join(skillDir, 'README.md'), readme);
+  console.log(`✓ Created: README.md`);
+
+  // Create log file
+  const logFile = join(skillDir, `${meta.name}.log`);
+  if (!existsSync(logFile)) {
+    writeFileSync(logFile, `# ${meta.name} execution log\n# Created: ${new Date().toISOString()}\n\n`);
+    console.log(`✓ Created: ${meta.name}.log`);
+  }
+
+  console.log('');
+  console.log(`✅ ${meta.name} installed successfully!`);
+  console.log('');
+  console.log('Location:', skillDir);
+  console.log('');
+  console.log('Files created:');
+  console.log('  - SKILL.md (documentation)');
+  console.log('  - README.md (quick reference)');
+  console.log(`  - ${meta.name}.log (execution logs)`);
+}
+
+async function uninstallSkill(meta: SkillMeta, assistant: string): Promise<void> {
+  console.log(`🗑️  Uninstalling ${meta.name} from ${assistant}...`);
+  console.log('');
+
+  const assistantPaths: Record<string, string> = {
+    claude: '.claude/skills',
+    codex: '.codex/skills',
+    windsurf: '.windsurf/skills',
+    cursor: '.cursor/skills',
+  };
+
+  const skillDir = join(homedir(), assistantPaths[assistant], meta.name);
+
+  if (existsSync(skillDir)) {
+    console.log(`⚠️  Directory preserved: ${skillDir}`);
+    console.log('   (contains logs and configuration)');
+    console.log('   Delete manually if needed:');
+    console.log(`   rm -rf ${skillDir}`);
+  } else {
+    console.log(`✓ ${meta.name} is not installed for ${assistant}`);
+  }
+}
+
+function generateSkillMd(meta: SkillMeta): string {
+  // Extract skill type from name (e.g., "skill-audio" -> "audio")
+  const skillType = meta.name.replace('skill-', '');
+
+  // Create gerund form for description trigger (e.g., "audio" -> "generating audio")
+  const gerundForms: Record<string, string> = {
+    audio: 'generating audio',
+    image: 'generating images',
+    video: 'generating videos',
+    browse: 'browsing websites',
+    codefix: 'fixing code',
+    convert: 'converting files',
+    deploy: 'deploying applications',
+    emoji: 'generating emojis',
+    extract: 'extracting data',
+    transcript: 'transcribing audio',
+    transform: 'transforming data',
+    write: 'writing content',
+  };
+
+  const gerund = gerundForms[skillType] || `using ${skillType}`;
+
+  // Enhanced description with usage triggers
+  const enhancedDesc = `${meta.description}. Use when ${gerund} or when the user mentions ${skillType}.`;
+
+  const envSection = meta.requiredEnvVars?.length ? `
+
+## Environment Variables
+
+${meta.requiredEnvVars.map(v => `- \`${v}\``).join('\n')}
+
+Add to your \`~/.zshrc\` or \`~/.bashrc\`:
+\`\`\`bash
+${meta.requiredEnvVars.map(v => `export ${v}=your_key_here`).join('\n')}
+\`\`\`
+` : '';
+
+  return `---
+name: ${meta.name}
+description: ${enhancedDesc}
+---
+
+# ${meta.name.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ')}
+
+${meta.description}
+
+## Quick Start
+
+\`\`\`bash
+${meta.commands}
+\`\`\`
+
+## Version
+
+${meta.version}${envSection}
+
+## Installation
+
+Installed at: \`~/.claude/skills/${meta.name}/\`
+
+## Logs
+
+Execution logs: \`~/.claude/skills/${meta.name}/${meta.name}.log\`
+
+## Support
+
+For issues, visit: https://github.com/hasnaxyz/${meta.name}/issues
+`;
+}
+
+function generateReadme(meta: SkillMeta): string {
+  return `# ${meta.name}
+
+${meta.description}
+
+**Version:** ${meta.version}
+
+## Documentation
+
+See [SKILL.md](./SKILL.md) for complete documentation.
+
+## Quick Reference
+
+\`\`\`bash
+${meta.name} --help
+\`\`\`
+`;
+}

package/skills/skill-e2bswarm/README.md

@@ -0,0 +1,135 @@
+# skill-e2bswarm
+
+Spawn E2B sandbox instances for parallel Claude Code task execution.
+
+## Overview
+
+This skill allows you to spawn multiple E2B sandboxes in parallel, each running Claude Code with a subset of tasks. This enables massively parallel task execution across isolated environments.
+
+## Installation
+
+```bash
+# Clone and install
+cd ~/Workspace/dev/hasnaxyz/skill/skilldev/skill-e2bswarm
+bun install
+
+# Link to Claude Code skills
+bun run link
+# or manually:
+ln -sf $(pwd) ~/.claude/skills/skill-e2bswarm
+```
+
+## Configuration
+
+Add your E2B API key to `~/.secrets`:
+
+```bash
+export E2B_API_KEY="your-api-key-here"
+```
+
+Get your API key at: https://e2b.dev/dashboard
+
+## Usage
+
+### As a Claude Code Skill
+
+Once linked, you can invoke the skill directly:
+
+```
+/skill-e2bswarm spawn --repo git@github.com:org/repo.git --tasks my-task-list --instances 4
+```
+
+### As a CLI
+
+```bash
+# Spawn instances with tasks from Claude Code task list
+bun run src/index.ts spawn \
+  --repo git@github.com:org/repo.git \
+  --tasks iapp-videoben-dev \
+  --instances 4 \
+  --distribute round-robin
+
+# From a JSON file
+bun run src/index.ts spawn \
+  --repo git@github.com:org/repo.git \
+  --tasks-file ./my-tasks.json \
+  --instances 2
+
+# From a directory of task files
+bun run src/index.ts spawn \
+  --repo git@github.com:org/repo.git \
+  --tasks-dir ./tasks/ \
+  --instances 3
+
+# Inline JSON
+bun run src/index.ts spawn \
+  --repo git@github.com:org/repo.git \
+  --tasks-json '[{"id":"1","subject":"Do something","description":"Details..."}]' \
+  --instances 1
+
+# Check status
+bun run src/index.ts status
+
+# Collect results
+bun run src/index.ts collect --output ./results
+
+# Kill all instances
+bun run src/index.ts kill
+
+# Clean up old instances
+bun run src/index.ts clean
+```
+
+## Task Distribution Modes
+
+| Mode | Description |
+|------|-------------|
+| `all` | Each instance receives all tasks (default) |
+| `round-robin` | Tasks distributed evenly across instances |
+| `by-dependency` | Tasks grouped by dependency chains |
+
+## Task Format
+
+Tasks follow the Claude Code task format:
+
+```json
+{
+  "id": "1",
+  "subject": "Brief task title",
+  "description": "Detailed description with acceptance criteria",
+  "activeForm": "Present tense action (e.g., 'Creating tests')",
+  "status": "pending",
+  "blocks": ["2", "3"],
+  "blockedBy": []
+}
+```
+
+See `examples/tasks-example.json` for a complete example.
+
+## How It Works
+
+1. **Spawn**: Creates E2B sandboxes, clones the repo, writes tasks, and starts Claude Code
+2. **Execute**: Each sandbox runs Claude Code with its assigned tasks
+3. **Collect**: Gathers results, updated tasks, and outputs from all sandboxes
+4. **Clean**: Removes old sandbox state
+
+## State Management
+
+Instance state is persisted to `~/.claude/skill-e2bswarm-state.json` between commands.
+
+## Development
+
+```bash
+# Watch mode
+bun run dev
+
+# Type check
+bun run typecheck
+
+# Build
+bun run build
+```
+
+## License
+
+MIT