@hasna/skills 0.1.26 → 0.1.29

package/skills/e2bswarm/src/lib/github.ts

@@ -1,253 +0,0 @@
-import { Sandbox } from 'e2b';
-import { mkdir } from 'node:fs/promises';
-import { join } from 'node:path';
-import type { SwarmInstance } from '../types';
-import { logger } from './logger';
-
-/**
- * Setup GitHub authentication in sandbox
- */
-export async function setupGitHubAuth(sandbox: Sandbox): Promise<void> {
-  // Check for GitHub token in environment
-  const ghToken = process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
-
-  if (ghToken) {
-    // Use token-based auth
-    await sandbox.commands.run(`
-      git config --global credential.helper store
-      echo "https://oauth2:${ghToken}@github.com" > ~/.git-credentials
-      git config --global user.email "swarm@e2b.dev"
-      git config --global user.name "E2B Swarm"
-    `);
-    return;
-  }
-
-  // Try to copy SSH key from local machine
-  const sshKeyPath = `${process.env.HOME}/.ssh/id_ed25519`;
-  try {
-    const privateKey = await Bun.file(sshKeyPath).text();
-    const publicKey = await Bun.file(`${sshKeyPath}.pub`).text();
-
-    await sandbox.commands.run('mkdir -p ~/.ssh && chmod 700 ~/.ssh');
-    await sandbox.files.write('/home/user/.ssh/id_ed25519', privateKey);
-    await sandbox.files.write('/home/user/.ssh/id_ed25519.pub', publicKey);
-    await sandbox.commands.run(`
-      chmod 600 ~/.ssh/id_ed25519
-      chmod 644 ~/.ssh/id_ed25519.pub
-      ssh-keyscan github.com >> ~/.ssh/known_hosts 2>/dev/null
-      git config --global user.email "swarm@e2b.dev"
-      git config --global user.name "E2B Swarm"
-    `);
-    return;
-  } catch {
-    // SSH key not found, try id_rsa
-  }
-
-  const rsaKeyPath = `${process.env.HOME}/.ssh/id_rsa`;
-  try {
-    const privateKey = await Bun.file(rsaKeyPath).text();
-    const publicKey = await Bun.file(`${rsaKeyPath}.pub`).text();
-
-    await sandbox.commands.run('mkdir -p ~/.ssh && chmod 700 ~/.ssh');
-    await sandbox.files.write('/home/user/.ssh/id_rsa', privateKey);
-    await sandbox.files.write('/home/user/.ssh/id_rsa.pub', publicKey);
-    await sandbox.commands.run(`
-      chmod 600 ~/.ssh/id_rsa
-      chmod 644 ~/.ssh/id_rsa.pub
-      ssh-keyscan github.com >> ~/.ssh/known_hosts 2>/dev/null
-      git config --global user.email "swarm@e2b.dev"
-      git config --global user.name "E2B Swarm"
-    `);
-    return;
-  } catch {
-    // No SSH key found
-  }
-
-  logger.warn('No GitHub authentication found. Set GITHUB_TOKEN or ensure SSH keys exist.');
-}
-
-/**
- * Commit changes in the sandbox
- */
-export async function commitChanges(
-  sandbox: Sandbox,
-  message: string
-): Promise<{ success: boolean; error?: string }> {
-  // Stage all changes
-  const addResult = await sandbox.commands.run('cd /home/user/workspace && git add -A');
-  if (addResult.exitCode !== 0) {
-    return { success: false, error: `Failed to stage changes: ${addResult.stderr}` };
-  }
-
-  // Check if there are changes to commit
-  const statusResult = await sandbox.commands.run('cd /home/user/workspace && git status --porcelain');
-  if (!statusResult.stdout.trim()) {
-    return { success: true }; // No changes to commit
-  }
-
-  // Commit
-  const commitResult = await sandbox.commands.run(
-    `cd /home/user/workspace && git commit -m "${message.replace(/"/g, '\\"')}"`
-  );
-  if (commitResult.exitCode !== 0) {
-    return { success: false, error: `Failed to commit: ${commitResult.stderr}` };
-  }
-
-  return { success: true };
-}
-
-/**
- * Push changes to remote
- */
-export async function pushChanges(
-  sandbox: Sandbox,
-  branch?: string
-): Promise<{ success: boolean; error?: string }> {
-  const pushCmd = branch
-    ? `cd /home/user/workspace && git push -u origin ${branch}`
-    : 'cd /home/user/workspace && git push';
-
-  const result = await sandbox.commands.run(pushCmd, { timeoutMs: 60000 });
-  if (result.exitCode !== 0) {
-    return { success: false, error: `Failed to push: ${result.stderr}` };
-  }
-
-  return { success: true };
-}
-
-/**
- * Create a new branch
- */
-export async function createBranch(
-  sandbox: Sandbox,
-  branchName: string
-): Promise<{ success: boolean; error?: string }> {
-  const result = await sandbox.commands.run(
-    `cd /home/user/workspace && git checkout -b ${branchName}`
-  );
-  if (result.exitCode !== 0) {
-    return { success: false, error: `Failed to create branch: ${result.stderr}` };
-  }
-
-  return { success: true };
-}
-
-/**
- * Create a pull request using gh CLI
- */
-export async function createPullRequest(
-  sandbox: Sandbox,
-  options: {
-    title: string;
-    body: string;
-    base?: string;
-    draft?: boolean;
-  }
-): Promise<{ success: boolean; prUrl?: string; error?: string }> {
-  // Install gh CLI if not present
-  await sandbox.commands.run(`
-    which gh || (curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | sudo dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg && \
-    echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null && \
-    sudo apt update && sudo apt install gh -y) 2>/dev/null || true
-  `, { timeoutMs: 120000 });
-
-  // Check for GitHub token
-  const ghToken = process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
-  if (!ghToken) {
-    return { success: false, error: 'GITHUB_TOKEN not set. Cannot create PR.' };
-  }
-
-  // Authenticate gh CLI
-  await sandbox.commands.run(`echo "${ghToken}" | gh auth login --with-token`);
-
-  // Build PR command
-  const baseFlag = options.base ? `--base ${options.base}` : '';
-  const draftFlag = options.draft ? '--draft' : '';
-
-  const prCmd = `cd /home/user/workspace && gh pr create --title "${options.title.replace(/"/g, '\\"')}" --body "${options.body.replace(/"/g, '\\"')}" ${baseFlag} ${draftFlag}`;
-
-  const result = await sandbox.commands.run(prCmd, { timeoutMs: 60000 });
-  if (result.exitCode !== 0) {
-    return { success: false, error: `Failed to create PR: ${result.stderr}` };
-  }
-
-  // Extract PR URL from output
-  const prUrl = result.stdout.trim().split('\n').pop();
-
-  return { success: true, prUrl };
-}
-
-/**
- * Download changed files from sandbox to local export directory
- */
-export async function downloadChangedFiles(
-  sandbox: Sandbox,
-  instance: SwarmInstance
-): Promise<string[]> {
-  const exportDir = instance.exportDir;
-  if (!exportDir) return [];
-
-  // Get list of changed files
-  const diffResult = await sandbox.commands.run(
-    'cd /home/user/workspace && git diff --name-only HEAD~1 2>/dev/null || git diff --name-only'
-  );
-
-  const changedFiles = diffResult.stdout.trim().split('\n').filter(Boolean);
-  const downloadedFiles: string[] = [];
-
-  // Create changes directory
-  const changesDir = join(exportDir, 'changes');
-  await mkdir(changesDir, { recursive: true });
-
-  for (const file of changedFiles) {
-    try {
-      const content = await sandbox.files.read(`/home/user/workspace/${file}`);
-      const localPath = join(changesDir, file);
-      await mkdir(join(changesDir, file.split('/').slice(0, -1).join('/')), { recursive: true });
-      await Bun.write(localPath, content);
-      downloadedFiles.push(file);
-    } catch {
-      // File might have been deleted
-    }
-  }
-
-  return downloadedFiles;
-}
-
-/**
- * Get git status from sandbox
- */
-export async function getGitStatus(sandbox: Sandbox): Promise<{
-  branch: string;
-  ahead: number;
-  behind: number;
-  modified: string[];
-  added: string[];
-  deleted: string[];
-}> {
-  const branchResult = await sandbox.commands.run('cd /home/user/workspace && git branch --show-current');
-  const statusResult = await sandbox.commands.run('cd /home/user/workspace && git status --porcelain');
-
-  const modified: string[] = [];
-  const added: string[] = [];
-  const deleted: string[] = [];
-
-  for (const line of statusResult.stdout.split('\n')) {
-    if (!line.trim()) continue;
-    const status = line.slice(0, 2);
-    const file = line.slice(3);
-
-    if (status.includes('M')) modified.push(file);
-    if (status.includes('A') || status === '??') added.push(file);
-    if (status.includes('D')) deleted.push(file);
-  }
-
-  return {
-    branch: branchResult.stdout.trim(),
-    ahead: 0,
-    behind: 0,
-    modified,
-    added,
-    deleted,
-  };
-}

package/skills/e2bswarm/src/lib/logger.ts

@@ -1,41 +0,0 @@
-import chalk from 'chalk';
-
-export const logger = {
-  info: (msg: string) => console.log(chalk.blue('ℹ'), msg),
-  success: (msg: string) => console.log(chalk.green('✓'), msg),
-  warn: (msg: string) => console.log(chalk.yellow('⚠'), msg),
-  error: (msg: string) => console.log(chalk.red('✗'), msg),
-  debug: (msg: string) => {
-    if (process.env.DEBUG) console.log(chalk.gray('⋯'), msg);
-  },
-
-  instance: (id: string, status: string, msg?: string) => {
-    const statusColors: Record<string, (s: string) => string> = {
-      starting: chalk.yellow,
-      cloning: chalk.blue,
-      'setting-up': chalk.blue,
-      running: chalk.cyan,
-      completed: chalk.green,
-      failed: chalk.red,
-    };
-    const colorFn = statusColors[status] || chalk.white;
-    const shortId = id.slice(0, 8);
-    console.log(`  ${chalk.gray(`[${shortId}]`)} ${colorFn(status.padEnd(10))} ${msg || ''}`);
-  },
-
-  table: (data: Array<Record<string, unknown>>) => {
-    if (data.length === 0) {
-      console.log(chalk.gray('  No data'));
-      return;
-    }
-    console.table(data);
-  },
-
-  divider: () => console.log(chalk.gray('─'.repeat(60))),
-
-  header: (title: string) => {
-    console.log();
-    console.log(chalk.bold.white(title));
-    logger.divider();
-  },
-};

package/skills/e2bswarm/src/lib/paths.ts

@@ -1,75 +0,0 @@
-import { mkdir } from 'node:fs/promises';
-import { join } from 'node:path';
-
-/**
- * Standard skill data directory structure
- *
- * ~/.skills/
- * └── [name]/
- *     ├── exports/     # Output data, results, artifacts
- *     ├── logs/        # Execution logs, debug info
- *     ├── cache/       # Temporary cached data
- *     └── config/      # Skill-specific configuration
- */
-
-const SKILL_NAME = 'e2bswarm';
-const SKILLS_ROOT = join(process.env.HOME!, '.skills');
-const SKILL_DATA_DIR = join(SKILLS_ROOT, SKILL_NAME);
-
-export const paths = {
-  // Root directories
-  skillsRoot: SKILLS_ROOT,
-  skillData: SKILL_DATA_DIR,
-
-  // Standard subdirectories
-  exports: join(SKILL_DATA_DIR, 'exports'),
-  logs: join(SKILL_DATA_DIR, 'logs'),
-  cache: join(SKILL_DATA_DIR, 'cache'),
-  config: join(SKILL_DATA_DIR, 'config'),
-
-  // State file (moved from ~/.claude/)
-  state: join(SKILL_DATA_DIR, 'state.json'),
-
-  // Helper to get timestamped export directory
-  getExportDir: (prefix?: string) => {
-    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
-    const dirName = prefix ? `${prefix}-${timestamp}` : timestamp;
-    return join(SKILL_DATA_DIR, 'exports', dirName);
-  },
-
-  // Helper to get log file path
-  getLogFile: (name: string) => {
-    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
-    return join(SKILL_DATA_DIR, 'logs', `${name}-${timestamp}.log`);
-  },
-
-  // Helper to get instance-specific paths
-  getInstance: (instanceId: string) => ({
-    exports: join(SKILL_DATA_DIR, 'exports', instanceId),
-    logs: join(SKILL_DATA_DIR, 'logs', instanceId),
-  }),
-};
-
-/**
- * Ensure all skill directories exist
- */
-export async function ensureSkillDirs(): Promise<void> {
-  await mkdir(paths.exports, { recursive: true });
-  await mkdir(paths.logs, { recursive: true });
-  await mkdir(paths.cache, { recursive: true });
-  await mkdir(paths.config, { recursive: true });
-}
-
-/**
- * Get skill data path for any skill (reusable utility)
- */
-export function getSkillPaths(skillName: string) {
-  const skillDir = join(SKILLS_ROOT, skillName);
-  return {
-    root: skillDir,
-    exports: join(skillDir, 'exports'),
-    logs: join(skillDir, 'logs'),
-    cache: join(skillDir, 'cache'),
-    config: join(skillDir, 'config'),
-  };
-}

package/skills/e2bswarm/src/lib/tasks.ts

@@ -1,320 +0,0 @@
-import { readdir } from 'node:fs/promises';
-import { join, resolve } from 'node:path';
-import type { Task, TaskSource, SpawnOptions } from '../types';
-import { logger } from './logger';
-
-/**
- * Determine the task source from spawn options
- */
-export function determineTaskSource(options: SpawnOptions): TaskSource {
-  if (options.tasksJson) {
-    return { type: 'json', value: options.tasksJson };
-  }
-  if (options.tasksFile) {
-    return { type: 'file', value: resolve(options.tasksFile) };
-  }
-  if (options.tasksDir) {
-    return { type: 'directory', value: resolve(options.tasksDir) };
-  }
-  if (options.tasks) {
-    // Check if it's a path or a task list ID
-    if (options.tasks.includes('/') || options.tasks.endsWith('.json')) {
-      return { type: 'file', value: resolve(options.tasks) };
-    }
-    return { type: 'task-list-id', value: options.tasks };
-  }
-  throw new Error(
-    'No task source provided. Use one of:\n' +
-    '  --tasks <task-list-id>     Load from ~/.claude/tasks/<id>/\n' +
-    '  --tasks-dir <directory>    Load from a local directory\n' +
-    '  --tasks-file <file.json>   Load from a JSON file\n' +
-    '  --tasks-json \'[...]\''+ '       Inline JSON array'
-  );
-}
-
-/**
- * Load tasks from various sources
- */
-export async function loadTasks(source: TaskSource): Promise<Task[]> {
-  switch (source.type) {
-    case 'json':
-      return parseTasksJson(source.value);
-
-    case 'file':
-      return loadTasksFromFile(source.value);
-
-    case 'directory':
-      return loadTasksFromDirectory(source.value);
-
-    case 'task-list-id':
-      return loadTasksFromTaskList(source.value);
-
-    default:
-      throw new Error(`Unknown task source type`);
-  }
-}
-
-/**
- * Parse inline JSON tasks
- */
-function parseTasksJson(json: string): Task[] {
-  try {
-    const parsed = JSON.parse(json);
-    const tasks = Array.isArray(parsed) ? parsed : [parsed];
-    return validateTasks(tasks);
-  } catch (error) {
-    throw new Error(`Failed to parse tasks JSON: ${error}`);
-  }
-}
-
-/**
- * Load tasks from a JSON file
- */
-async function loadTasksFromFile(filePath: string): Promise<Task[]> {
-  try {
-    const content = await Bun.file(filePath).text();
-    const parsed = JSON.parse(content);
-    const tasks = Array.isArray(parsed) ? parsed : [parsed];
-    logger.debug(`Loaded ${tasks.length} tasks from file: ${filePath}`);
-    return validateTasks(tasks);
-  } catch (error) {
-    throw new Error(`Failed to load tasks from file ${filePath}: ${error}`);
-  }
-}
-
-/**
- * Load tasks from a directory containing JSON files
- */
-async function loadTasksFromDirectory(dirPath: string): Promise<Task[]> {
-  try {
-    const files = await readdir(dirPath);
-    const jsonFiles = files.filter(f => f.endsWith('.json'));
-
-    if (jsonFiles.length === 0) {
-      throw new Error(`No JSON files found in directory: ${dirPath}`);
-    }
-
-    const tasks: Task[] = [];
-    for (const file of jsonFiles) {
-      const content = await Bun.file(join(dirPath, file)).text();
-      const task = JSON.parse(content);
-      tasks.push(task);
-    }
-
-    logger.debug(`Loaded ${tasks.length} tasks from directory: ${dirPath}`);
-    return validateTasks(tasks);
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-      throw new Error(`Directory not found: ${dirPath}`);
-    }
-    throw error;
-  }
-}
-
-/**
- * Load tasks from Claude Code task list (~/.claude/tasks/<id>/)
- */
-async function loadTasksFromTaskList(taskListId: string): Promise<Task[]> {
-  const tasksDir = join(process.env.HOME!, '.claude', 'tasks', taskListId);
-
-  try {
-    const files = await readdir(tasksDir);
-    const jsonFiles = files.filter(f => f.endsWith('.json'));
-
-    if (jsonFiles.length === 0) {
-      throw new Error(`No tasks found in task list: ${taskListId}`);
-    }
-
-    const tasks: Task[] = [];
-    for (const file of jsonFiles) {
-      const content = await Bun.file(join(tasksDir, file)).text();
-      const task = JSON.parse(content);
-      tasks.push(task);
-    }
-
-    logger.debug(`Loaded ${tasks.length} tasks from task list: ${taskListId}`);
-    return validateTasks(tasks);
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-      throw new Error(
-        `Task list not found: ${taskListId}\n` +
-        `Expected location: ${tasksDir}\n\n` +
-        'Available task lists can be found in ~/.claude/tasks/'
-      );
-    }
-    throw error;
-  }
-}
-
-/**
- * Validate and normalize task objects
- */
-function validateTasks(tasks: unknown[]): Task[] {
-  return tasks.map((task, index) => {
-    if (!task || typeof task !== 'object') {
-      throw new Error(`Task at index ${index} is not an object`);
-    }
-
-    const t = task as Record<string, unknown>;
-
-    if (!t.id) {
-      t.id = String(index + 1);
-    }
-    if (!t.subject && !t.description) {
-      throw new Error(`Task ${t.id} must have a subject or description`);
-    }
-
-    return {
-      id: String(t.id),
-      subject: String(t.subject || t.description || ''),
-      description: String(t.description || t.subject || ''),
-      activeForm: t.activeForm ? String(t.activeForm) : undefined,
-      status: (t.status as Task['status']) || 'pending',
-      blocks: Array.isArray(t.blocks) ? t.blocks.map(String) : [],
-      blockedBy: Array.isArray(t.blockedBy) ? t.blockedBy.map(String) : [],
-      metadata: t.metadata as Record<string, unknown> | undefined,
-    };
-  });
-}
-
-/**
- * Filter tasks to only pending/in_progress
- */
-export function filterPendingTasks(tasks: Task[]): Task[] {
-  return tasks.filter(t => t.status !== 'completed');
-}
-
-/**
- * Distribute tasks across instances based on mode
- */
-export function distributeTasks(
-  tasks: Task[],
-  instanceCount: number,
-  mode: 'all' | 'round-robin' | 'by-dependency' = 'all'
-): Task[][] {
-  // Filter to pending tasks only
-  const pendingTasks = filterPendingTasks(tasks);
-
-  if (pendingTasks.length === 0) {
-    logger.warn('No pending tasks to distribute');
-    return Array(instanceCount).fill([]);
-  }
-
-  switch (mode) {
-    case 'all':
-      // Each instance gets all tasks
-      return Array(instanceCount).fill(null).map(() => [...pendingTasks]);
-
-    case 'round-robin':
-      // Distribute tasks evenly across instances
-      return distributeRoundRobin(pendingTasks, instanceCount);
-
-    case 'by-dependency':
-      // Group tasks by their dependency chains
-      return distributeByDependency(pendingTasks, instanceCount);
-
-    default:
-      return [pendingTasks];
-  }
-}
-
-function distributeRoundRobin(tasks: Task[], instanceCount: number): Task[][] {
-  const distribution: Task[][] = Array.from({ length: instanceCount }, () => []);
-
-  tasks.forEach((task, i) => {
-    distribution[i % instanceCount]!.push(task);
-  });
-
-  return distribution;
-}
-
-function distributeByDependency(tasks: Task[], maxGroups: number): Task[][] {
-  const chains: Task[][] = [];
-  const assigned = new Set<string>();
-
-  // Find all tasks that have no blockers (roots)
-  const roots = tasks.filter(t => t.blockedBy.length === 0);
-
-  for (const root of roots) {
-    if (assigned.has(root.id)) continue;
-    const chain = collectDependencyChain(root, tasks, assigned);
-    if (chain.length > 0) {
-      chains.push(chain);
-    }
-  }
-
-  // Add any orphaned tasks
-  for (const task of tasks) {
-    if (!assigned.has(task.id)) {
-      chains.push([task]);
-      assigned.add(task.id);
-    }
-  }
-
-  // Merge chains if we have more than maxGroups
-  while (chains.length > maxGroups && chains.length > 1) {
-    // Find the smallest chain
-    let smallestIdx = 0;
-    for (let i = 1; i < chains.length; i++) {
-      if (chains[i]!.length < chains[smallestIdx]!.length) {
-        smallestIdx = i;
-      }
-    }
-
-    // Merge with the next smallest
-    const smallest = chains.splice(smallestIdx, 1)[0]!;
-    let targetIdx = 0;
-    for (let i = 1; i < chains.length; i++) {
-      if (chains[i]!.length < chains[targetIdx]!.length) {
-        targetIdx = i;
-      }
-    }
-    chains[targetIdx]!.push(...smallest);
-  }
-
-  // Pad with empty arrays if we have fewer chains than instances
-  while (chains.length < maxGroups) {
-    chains.push([]);
-  }
-
-  return chains;
-}
-
-function collectDependencyChain(
-  task: Task,
-  allTasks: Task[],
-  assigned: Set<string>
-): Task[] {
-  if (assigned.has(task.id)) return [];
-
-  assigned.add(task.id);
-  const chain: Task[] = [task];
-
-  // Find tasks that this one blocks (dependents)
-  for (const t of allTasks) {
-    if (t.blockedBy.includes(task.id)) {
-      chain.push(...collectDependencyChain(t, allTasks, assigned));
-    }
-  }
-
-  return chain;
-}
-
-/**
- * Serialize tasks for writing to sandbox
- */
-export function serializeTasks(tasks: Task[]): string {
-  return JSON.stringify(tasks, null, 2);
-}
-
-/**
- * Create a summary of task distribution
- */
-export function summarizeDistribution(distribution: Task[][]): string {
-  const lines = distribution.map((tasks, i) => {
-    const subjects = tasks.slice(0, 3).map(t => t.subject.slice(0, 40));
-    const more = tasks.length > 3 ? ` (+${tasks.length - 3} more)` : '';
-    return `  Instance ${i + 1}: ${tasks.length} tasks${more}\n    ${subjects.join('\n    ')}`;
-  });
-  return lines.join('\n');
-}