@hasna/skills 0.0.2

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

@@ -0,0 +1,253 @@
+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/skill-e2bswarm/src/lib/logger.ts

@@ -0,0 +1,41 @@
+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/skill-e2bswarm/src/lib/paths.ts

@@ -0,0 +1,75 @@
+import { mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+
+/**
+ * Standard skill data directory structure
+ *
+ * ~/.skills/
+ * └── skill-[name]/
+ *     ├── exports/     # Output data, results, artifacts
+ *     ├── logs/        # Execution logs, debug info
+ *     ├── cache/       # Temporary cached data
+ *     └── config/      # Skill-specific configuration
+ */
+
+const SKILL_NAME = 'skill-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/skill-e2bswarm/src/lib/tasks.ts

@@ -0,0 +1,320 @@
+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');
+}