@lazyagent/lazy-agents 0.0.1

package/bin/lazy.js

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+'use strict';
+
+const { program } = require('commander');
+const path = require('path');
+const fs = require('fs');
+const { launch } = require('../src/launch');
+
+// ──────────────────────────────────────────────
+// Legacy backwards-compat: lazy --agents 3 [--session x]
+// Detect this form BEFORE commander parses anything, so it doesn't
+// interfere with subcommand option parsing.
+// ──────────────────────────────────────────────
+const argv = process.argv.slice(2);
+const isLegacy =
+  argv.length > 0 &&
+  !['launch', 'init', 'start', 'register', 'doctor', 'setup', '--help', '-h', '--version', '-V'].includes(argv[0]) &&
+  argv.some(a => a === '--agents' || a.startsWith('--agents='));
+
+if (isLegacy) {
+  // Parse --agents and --session from raw argv manually
+  let agents = null;
+  let session = null;
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === '--agents' && argv[i + 1]) agents = argv[++i];
+    else if (argv[i].startsWith('--agents=')) agents = argv[i].split('=')[1];
+    else if (argv[i] === '--session' && argv[i + 1]) session = argv[++i];
+    else if (argv[i].startsWith('--session=')) session = argv[i].split('=')[1];
+  }
+  if (agents) {
+    console.warn('[lazy] Warning: top-level --agents is deprecated. Use: lazy launch --agents');
+    launch({ agents, session: session || null, cwd: process.cwd(), platform: null });
+    process.exit(0);
+  }
+}
+
+program
+  .name('lazy')
+  .description('Launch Claude Code agents with automatic rate limit handling');
+
+// ──────────────────────────────────────────────
+// lazy launch
+// ──────────────────────────────────────────────
+program
+  .command('launch')
+  .description('Launch agents in terminal tabs')
+  .option('--agents <spec>', 'Number of agents or comma-separated roles (e.g. "3" or "architect,developer,tester")')
+  .option('--session <code>', 'Workspace session code (e.g. "swift-oak-17")')
+  .option('--cwd <path>', 'Working directory (default: current directory)')
+  .option('--platform <platform>', 'Terminal platform override: windows | mac | linux')
+  .action((opts) => {
+    if (!opts.agents) {
+      console.error('Error: --agents is required.\nExamples:\n  lazy launch --agents 3 --session swift-oak-17\n  lazy launch --agents architect,developer,tester');
+      process.exit(1);
+    }
+    launch({
+      agents: opts.agents,
+      session: opts.session || null,
+      cwd: opts.cwd || process.cwd(),
+      platform: opts.platform || null,
+    });
+  });
+
+// ──────────────────────────────────────────────
+// lazy init
+// ──────────────────────────────────────────────
+program
+  .command('init')
+  .description('Create a .lazy/config.json in the current directory')
+  .option('--agents <spec>', 'Number of agents or comma-separated roles')
+  .option('--session <code>', 'Workspace session code')
+  .action((opts) => {
+    const configDir = path.join(process.cwd(), '.lazy');
+    const configFile = path.join(configDir, 'config.json');
+
+    if (!fs.existsSync(configDir)) {
+      fs.mkdirSync(configDir, { recursive: true });
+    }
+
+    const config = {
+      agents: opts.agents || '3',
+      session: opts.session || null,
+    };
+
+    fs.writeFileSync(configFile, JSON.stringify(config, null, 2) + '\n', 'utf8');
+
+    console.log('[lazy] Created .lazy/config.json');
+    console.log('[lazy] Config:', JSON.stringify(config));
+    console.log('[lazy] Next steps:');
+    console.log('[lazy]   lazy setup   — create .claude/agents/ and .claude/mcp.json');
+    console.log('[lazy]   lazy start   — launch agents');
+  });
+
+// ──────────────────────────────────────────────
+// lazy start
+// ──────────────────────────────────────────────
+program
+  .command('start')
+  .description('Launch agents using .lazy/config.json (falls back to flags)')
+  .option('--agents <spec>', 'Fallback agent spec if no config file found')
+  .option('--session <code>', 'Fallback session code if no config file found')
+  .option('--cwd <path>', 'Working directory (default: current directory)')
+  .option('--platform <platform>', 'Terminal platform override: windows | mac | linux')
+  .action((opts) => {
+    const configFile = path.join(process.cwd(), '.lazy', 'config.json');
+    let config = {};
+
+    if (fs.existsSync(configFile)) {
+      try {
+        config = JSON.parse(fs.readFileSync(configFile, 'utf8'));
+        console.log('[lazy] Loaded config from .lazy/config.json');
+      } catch (err) {
+        console.error('[lazy] Failed to parse .lazy/config.json:', err.message);
+        process.exit(1);
+      }
+    } else {
+      console.log('[lazy] No .lazy/config.json found — falling back to flags');
+    }
+
+    const agents = config.agents || opts.agents;
+    if (!agents) {
+      console.error('Error: --agents is required when no .lazy/config.json exists.');
+      process.exit(1);
+    }
+
+    launch({
+      agents,
+      session: config.session || opts.session || null,
+      cwd: opts.cwd || process.cwd(),
+      platform: opts.platform || null,
+    });
+  });
+
+// ──────────────────────────────────────────────
+// lazy register
+// ──────────────────────────────────────────────
+program
+  .command('register')
+  .description('Show the claude command that registers an agent in the backend workspace')
+  .option('--name <name>', 'Agent name (e.g. "architect-1")')
+  .option('--role <role>', 'Agent role (e.g. "architect")')
+  .option('--session <code>', 'Workspace session code')
+  .option('--server <url>', 'Backend server URL (e.g. "http://localhost:3000")')
+  .action((opts) => {
+    const missing = ['name', 'role', 'session', 'server'].filter(k => !opts[k]);
+    if (missing.length) {
+      console.error(`Error: missing required flags: ${missing.map(k => '--' + k).join(', ')}`);
+      console.error('Usage: lazy register --name architect-1 --role architect --session swift-oak-17 --server http://localhost:3000');
+      process.exit(1);
+    }
+
+    const prompt = [
+      `Register as ${opts.name}, role ${opts.role}`,
+      `session code: ${opts.session}`,
+      `server: ${opts.server}`,
+    ].join(', ');
+
+    const cmd = `claude '${prompt}'`;
+    console.log('[lazy] Command to run:');
+    console.log(cmd);
+  });
+
+// ──────────────────────────────────────────────
+// lazy setup
+// ──────────────────────────────────────────────
+program
+  .command('setup')
+  .description('Create .claude/agents/ sub-agents and .claude/mcp.json for Claude Code')
+  .option('--github-token <token>', 'GitHub Personal Access Token (falls back to $GITHUB_TOKEN)')
+  .option('--agents <roles>', 'Comma-separated roles to create (default: all). Options: architect,developer,tester,reviewer,researcher,debugger,planner,security')
+  .option('--mcp-only', 'Only create .claude/mcp.json, skip agent files')
+  .option('--agents-only', 'Only create .claude/agents/, skip mcp.json')
+  .option('--force', 'Overwrite existing files')
+  .option('--cwd <path>', 'Target directory (default: current directory)')
+  .option('--no-interactive', 'Skip interactive prompts (CI-friendly)')
+  .action(async (opts) => {
+    const { setup } = require('../src/setup');
+    await setup({
+      githubToken: opts.githubToken || null,
+      agents: opts.agents || null,
+      mcpOnly: opts.mcpOnly || false,
+      agentsOnly: opts.agentsOnly || false,
+      force: opts.force || false,
+      cwd: opts.cwd || process.cwd(),
+      interactive: opts.interactive !== false,
+    });
+  });
+
+// ──────────────────────────────────────────────
+// lazy doctor
+// ──────────────────────────────────────────────
+program
+  .command('doctor')
+  .description('Check environment: node version, Windows Terminal, claude CLI')
+  .action(async () => {
+    const { doctor } = require('../src/doctor');
+    await doctor();
+  });
+
+program.parse(process.argv);

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@lazyagent/lazy-agents",
+  "version": "0.0.1",
+  "description": "Launch multiple Claude Code agents with automatic rate limit handling",
+  "license": "MIT",
+  "keywords": [
+    "claude",
+    "ai",
+    "agents",
+    "cli",
+    "automation"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/oshri1997/let-me-being-lazy.git"
+  },
+  "homepage": "https://github.com/oshri1997/let-me-being-lazy#readme",
+  "bin": {
+    "lazy": "./bin/lazy.js"
+  },
+  "main": "./src/launch.js",
+  "files": [
+    "bin",
+    "src",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "jest"
+  },
+  "dependencies": {
+    "commander": "^12.0.0",
+    "node-pty": "^1.0.0"
+  },
+  "devDependencies": {
+    "jest": "^29.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/cli.test.js

@@ -0,0 +1,135 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const { execFile } = require('child_process');
+
+const LAZY_BIN = path.join(__dirname, '..', 'bin', 'lazy.js');
+
+// Helper: run lazy CLI, returns { code, stdout, stderr }
+function runLazy(args, opts = {}) {
+  return new Promise((resolve) => {
+    execFile(process.execPath, [LAZY_BIN, ...args], opts, (err, stdout, stderr) => {
+      resolve({ code: err ? err.code : 0, stdout: stdout || '', stderr: stderr || '' });
+    });
+  });
+}
+
+// ──────────────────────────────────────────────
+// lazy init
+// ──────────────────────────────────────────────
+describe('lazy init', () => {
+  let tmpDir;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'lazy-init-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  test('creates .lazy/config.json with default agents=3', async () => {
+    const result = await runLazy(['init'], { cwd: tmpDir, timeout: 8000 });
+    expect(result.code).toBe(0);
+    const configFile = path.join(tmpDir, '.lazy', 'config.json');
+    expect(fs.existsSync(configFile)).toBe(true);
+    const config = JSON.parse(fs.readFileSync(configFile, 'utf8'));
+    expect(config.agents).toBe('3');
+  });
+
+  test('creates .lazy/config.json with --agents flag', async () => {
+    const result = await runLazy(['init', '--agents', 'architect,developer'], { cwd: tmpDir, timeout: 8000 });
+    expect(result.code).toBe(0);
+    const configFile = path.join(tmpDir, '.lazy', 'config.json');
+    const config = JSON.parse(fs.readFileSync(configFile, 'utf8'));
+    expect(config.agents).toBe('architect,developer');
+  });
+
+  test('creates .lazy/config.json with --session flag', async () => {
+    const result = await runLazy(['init', '--session', 'swift-oak-17'], { cwd: tmpDir, timeout: 8000 });
+    expect(result.code).toBe(0);
+    const configFile = path.join(tmpDir, '.lazy', 'config.json');
+    const config = JSON.parse(fs.readFileSync(configFile, 'utf8'));
+    expect(config.session).toBe('swift-oak-17');
+  });
+
+  test('prints next step message', async () => {
+    const result = await runLazy(['init'], { cwd: tmpDir, timeout: 8000 });
+    expect(result.stdout).toMatch(/lazy start/);
+  });
+
+  test('config.json is valid JSON', async () => {
+    await runLazy(['init'], { cwd: tmpDir, timeout: 8000 });
+    const raw = fs.readFileSync(path.join(tmpDir, '.lazy', 'config.json'), 'utf8');
+    expect(() => JSON.parse(raw)).not.toThrow();
+  });
+
+  test('overwrites existing config without error', async () => {
+    await runLazy(['init', '--agents', '2'], { cwd: tmpDir, timeout: 8000 });
+    const result = await runLazy(['init', '--agents', '5'], { cwd: tmpDir, timeout: 8000 });
+    expect(result.code).toBe(0);
+    const config = JSON.parse(fs.readFileSync(path.join(tmpDir, '.lazy', 'config.json'), 'utf8'));
+    expect(config.agents).toBe('5');
+  });
+});
+
+// ──────────────────────────────────────────────
+// lazy launch
+// ──────────────────────────────────────────────
+describe('lazy launch', () => {
+  test('exits non-zero and prints error when --agents is missing', async () => {
+    const result = await runLazy(['launch'], { timeout: 5000 });
+    expect(result.code).not.toBe(0);
+    expect(result.stderr + result.stdout).toMatch(/--agents is required/i);
+  }, 8000);
+});
+
+// ──────────────────────────────────────────────
+// lazy doctor
+// ──────────────────────────────────────────────
+describe('lazy doctor', () => {
+  test('exits 0 and prints check results', async () => {
+    const result = await runLazy(['doctor'], { timeout: 10000 });
+    // Doctor should not crash — exit 0 even if some checks fail
+    expect(result.code).toBe(0);
+    // Should output tick or cross marks
+    expect(result.stdout).toMatch(/[✓✗]/);
+  }, 12000);
+
+  test('reports Node.js version', async () => {
+    const result = await runLazy(['doctor'], { timeout: 10000 });
+    expect(result.stdout).toMatch(/Node\.js/);
+  }, 12000);
+
+  test('reports claude CLI check', async () => {
+    const result = await runLazy(['doctor'], { timeout: 10000 });
+    expect(result.stdout).toMatch(/claude/i);
+  }, 12000);
+});
+
+// ──────────────────────────────────────────────
+// lazy register
+// ──────────────────────────────────────────────
+describe('lazy register', () => {
+  test('prints the claude command when all flags provided', async () => {
+    const result = await runLazy([
+      'register',
+      '--name', 'architect-1',
+      '--role', 'architect',
+      '--session', 'swift-oak-17',
+      '--server', 'http://localhost:3000',
+    ], { timeout: 5000 });
+    expect(result.code).toBe(0);
+    expect(result.stdout).toMatch(/claude/);
+    expect(result.stdout).toMatch(/architect-1/);
+    expect(result.stdout).toMatch(/swift-oak-17/);
+  }, 8000);
+
+  test('exits non-zero when flags are missing', async () => {
+    const result = await runLazy(['register', '--name', 'arch-1'], { timeout: 5000 });
+    expect(result.code).not.toBe(0);
+    expect(result.stderr + result.stdout).toMatch(/missing required flags/i);
+  }, 8000);
+});

package/src/doctor.js

@@ -0,0 +1,70 @@
+'use strict';
+
+const { execFile } = require('child_process');
+const os = require('os');
+
+function check(label, pass, fixMsg) {
+  const icon = pass ? '\u2713' : '\u2717';
+  console.log(`  ${icon} ${label}`);
+  if (!pass && fixMsg) console.log(`      ${fixMsg}`);
+  return pass;
+}
+
+function which(bin) {
+  return new Promise((resolve) => {
+    const cmd = os.platform() === 'win32' ? 'where' : 'which';
+    execFile(cmd, [bin], (err) => resolve(!err));
+  });
+}
+
+async function doctor() {
+  console.log('[lazy] Running environment checks...\n');
+
+  // Node version
+  const nodeVersion = process.versions.node;
+  const [major] = nodeVersion.split('.').map(Number);
+  check(
+    `Node.js ${nodeVersion}`,
+    major >= 18,
+    'Node.js 18+ is required. Download from https://nodejs.org'
+  );
+
+  // claude CLI
+  const hasClaude = await which('claude');
+  check(
+    'claude CLI',
+    hasClaude,
+    'Claude Code CLI not found. Install via: npm install -g @anthropic-ai/claude-code'
+  );
+
+  // Platform-specific terminal
+  const platform = os.platform();
+  if (platform === 'win32') {
+    const hasWt = await which('wt');
+    check(
+      'Windows Terminal (wt)',
+      hasWt,
+      'Install Windows Terminal from https://aka.ms/terminal or the Microsoft Store'
+    );
+  } else if (platform === 'darwin') {
+    // Terminal.app always exists on macOS — check for osascript instead
+    const hasOsascript = await which('osascript');
+    check(
+      'osascript (Terminal automation)',
+      hasOsascript,
+      'osascript is part of macOS — this check should always pass'
+    );
+  } else {
+    const hasGnome = await which('gnome-terminal');
+    const hasXterm = await which('xterm');
+    check(
+      'gnome-terminal or xterm',
+      hasGnome || hasXterm,
+      'Install a terminal emulator: sudo apt install gnome-terminal  OR  sudo apt install xterm'
+    );
+  }
+
+  console.log('\n[lazy] Doctor done.');
+}
+
+module.exports = { doctor };

package/src/launch.js

@@ -0,0 +1,132 @@
+'use strict';
+
+const { exec } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+const WRAPPER = path.join(__dirname, 'wrapper.js');
+
+const DEFAULT_ROLES = ['architect', 'developer', 'tester'];
+
+function parseAgentSpec(spec) {
+  const num = parseInt(spec, 10);
+  if (!isNaN(num) && String(num) === spec.trim()) {
+    return Array.from({ length: num }, (_, i) => ({
+      name: `${DEFAULT_ROLES[i] || 'generic'}-${i + 1}`,
+      role: DEFAULT_ROLES[i] || 'generic',
+    }));
+  }
+  return spec.split(',').map((role, i) => ({
+    name: `${role.trim()}-${i + 1}`,
+    role: role.trim(),
+  }));
+}
+
+// ──────────────────────────────────────────────
+// Windows Terminal (wt) command builder
+// ──────────────────────────────────────────────
+function buildWtCommand(agents, session, wrapperPath, cwd = process.cwd()) {
+  const fwdWrapper = wrapperPath.replace(/\\/g, '/');
+  const tabs = agents.map((a, i) => {
+    const prompt = `Register as ${a.name}, role ${a.role}${session ? ', session code: ' + session : ''}`;
+    const tmpFile = path.join(os.tmpdir(), `lazy-prompt-${Date.now()}-${i}.txt`).replace(/\\/g, '/');
+    fs.writeFileSync(tmpFile, prompt, 'utf8');
+    const prefix = i === 0 ? 'new-tab' : '; new-tab';
+    return `${prefix} --startingDirectory "${cwd}" --title "${a.name} (${a.role})" -- powershell -NoExit -Command "node '${fwdWrapper}' '${tmpFile}'"`;
+  });
+  return `wt ${tabs.join('')}`;
+}
+
+// ──────────────────────────────────────────────
+// macOS — open one Terminal.app window per agent via osascript
+// ──────────────────────────────────────────────
+function buildMacCommand(agents, session, wrapperPath, cwd = process.cwd()) {
+  const cmds = agents.map((a) => {
+    const prompt = `Register as ${a.name}, role ${a.role}${session ? ', session code: ' + session : ''}`;
+    const escaped = prompt.replace(/"/g, '\\"').replace(/'/g, "\\'");
+    const nodeCmd = `node '${wrapperPath}' '${escaped}'`;
+    // osascript: tell Terminal to open a new window and run the command
+    return (
+      `osascript -e 'tell application "Terminal" to do script` +
+      ` "cd ${cwd} && ${nodeCmd}"'`
+    );
+  });
+  // Chain all osascript calls with &&
+  return cmds.join(' && ');
+}
+
+// ──────────────────────────────────────────────
+// Linux — try gnome-terminal, fall back to xterm
+// ──────────────────────────────────────────────
+function buildLinuxCommand(agents, session, wrapperPath, cwd = process.cwd()) {
+  const tabs = agents.map((a) => {
+    const prompt = `Register as ${a.name}, role ${a.role}${session ? ', session code: ' + session : ''}`;
+    const escaped = prompt.replace(/"/g, '\\"');
+    return `--tab --title="${a.name} (${a.role})" --working-directory="${cwd}" -- bash -c "node '${wrapperPath}' '${escaped}'; exec bash"`;
+  });
+  return `gnome-terminal ${tabs.join(' ')}`;
+}
+
+// ──────────────────────────────────────────────
+// Unified platform dispatcher
+// ──────────────────────────────────────────────
+function detectPlatform() {
+  const p = os.platform();
+  if (p === 'win32') return 'windows';
+  if (p === 'darwin') return 'mac';
+  return 'linux';
+}
+
+/**
+ * Build a terminal command for the given platform.
+ *
+ * @param {string} platform  'windows' | 'mac' | 'linux'
+ * @param {Array}  agents    parsed agent objects [{name, role}]
+ * @param {string} session   session code or null
+ * @param {string} wrapperPath  absolute path to wrapper.js
+ * @param {string} cwd       working directory
+ * @returns {string}  shell command to execute
+ */
+function buildTerminalCommand(platform, agents, session, wrapperPath, cwd = process.cwd()) {
+  switch (platform) {
+    case 'mac':    return buildMacCommand(agents, session, wrapperPath, cwd);
+    case 'linux':  return buildLinuxCommand(agents, session, wrapperPath, cwd);
+    case 'windows':
+    default:       return buildWtCommand(agents, session, wrapperPath, cwd);
+  }
+}
+
+// ──────────────────────────────────────────────
+// Launch
+// ──────────────────────────────────────────────
+function launch({ agents: spec, session, cwd, platform }) {
+  const agents = parseAgentSpec(spec);
+  const resolvedCwd = cwd || process.cwd();
+  const resolvedPlatform = platform || detectPlatform();
+
+  console.log('[lazy] Launching agents:');
+  agents.forEach(a => console.log(`  - ${a.name} (${a.role})`));
+  if (session) console.log(`[lazy] Session: ${session}`);
+  console.log(`[lazy] Platform: ${resolvedPlatform}`);
+
+  const cmd = buildTerminalCommand(resolvedPlatform, agents, session, WRAPPER, resolvedCwd);
+
+  const execCmd = resolvedPlatform === 'windows' ? `start "" ${cmd}` : cmd;
+
+  exec(execCmd, (err) => {
+    if (err) {
+      const hints = {
+        windows: 'Make sure "wt" (Windows Terminal) is installed.',
+        mac: 'Make sure Terminal.app is available (or use --platform linux).',
+        linux: 'Make sure gnome-terminal or xterm is installed.',
+      };
+      console.error('[lazy] Failed to launch terminal:', err.message);
+      console.error(`[lazy] ${hints[resolvedPlatform] || ''}`);
+      process.exit(1);
+    }
+  });
+  console.log('[lazy] Terminal launched. Each tab handles rate limits automatically.');
+}
+
+module.exports = { launch, parseAgentSpec, buildWtCommand, buildTerminalCommand, buildMacCommand, buildLinuxCommand };