@wipal/agent-team 1.0.0

package/src/commands/init.js

@@ -0,0 +1,136 @@
+/**
+ * Init command - Initialize .claude/ structure in project
+ */
+
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import { getClaudeDir, getProjectRoot, copyRules } from '../utils/file-utils.js';
+
+/**
+ * Initialize .claude/ structure
+ */
+export async function initCommand(options) {
+  const projectRoot = getProjectRoot();
+  const claudeDir = getClaudeDir(projectRoot);
+
+  console.log(chalk.blue('📁 Initializing project...'));
+  console.log(chalk.gray(`   Project: ${projectRoot}`));
+  console.log('');
+
+  // Check if already initialized
+  if (await fs.exists(claudeDir)) {
+    if (!options.force) {
+      console.log(chalk.yellow('⚠️  .claude/ directory already exists'));
+      console.log(chalk.gray('   Use --force to overwrite'));
+      return;
+    }
+    console.log(chalk.yellow('   Removing existing .claude/ directory...'));
+    await fs.remove(claudeDir);
+  }
+
+  // Create directory structure
+  console.log(chalk.blue('   Creating directory structure...'));
+
+  await fs.ensureDir(path.join(claudeDir, 'agents'));
+  await fs.ensureDir(path.join(claudeDir, 'shared-skills'));
+  await fs.ensureDir(path.join(claudeDir, 'rules', 'common'));
+  await fs.ensureDir(path.join(claudeDir, 'rules', 'role-rules'));
+  await fs.ensureDir(path.join(claudeDir, 'rules', 'lessons'));
+  await fs.ensureDir(path.join(claudeDir, 'commands', 'roles'));
+  await fs.ensureDir(path.join(claudeDir, 'commands', 'utils'));
+  await fs.ensureDir(path.join(claudeDir, 'commands', 'workflows'));
+
+  // Create CLAUDE.md
+  const claudeMdPath = path.join(claudeDir, 'CLAUDE.md');
+  if (!(await fs.exists(claudeMdPath)) || options.force) {
+    const projectName = path.basename(projectRoot);
+    const claudeMdContent = `# Project Context: ${projectName}
+
+## Description
+[Brief description of the project]
+
+## Tech Stack
+- Frontend:
+- Backend:
+- Database:
+- Infrastructure:
+
+## Team Members (Agents)
+[List of configured agents - run 'npx @wipal/agent-team list' to see]
+
+## Getting Started
+1. Add agents: \`npx @wipal/agent-team add <name> <role> [options]\`
+2. List agents: \`npx @wipal/agent-team list\`
+3. Switch agent: Use the agent's CLAUDE.md file
+
+## Notes
+- Use Context7 MCP for documentation lookup
+- Run \`/retrospect-work\` at end of session
+- Update this file with project-specific context
+`;
+    await fs.writeFile(claudeMdPath, claudeMdContent);
+    console.log(chalk.green('   ✓ Created CLAUDE.md'));
+  }
+
+  // Create settings.json
+  const settingsPath = path.join(claudeDir, 'settings.json');
+  if (!(await fs.exists(settingsPath)) || options.force) {
+    const settingsContent = {
+      mcpServers: {
+        context7: {
+          command: 'npx',
+          args: ['-y', '@context7/mcp-server']
+        },
+        github: {
+          command: 'npx',
+          args: ['-y', '@modelcontextprotocol/server-github'],
+          env: {
+            GITHUB_TOKEN: '${GITHUB_TOKEN}'
+          }
+        }
+      }
+    };
+    await fs.writeJson(settingsPath, settingsContent, { spaces: 2 });
+    console.log(chalk.green('   ✓ Created settings.json'));
+  }
+
+  // Copy rules
+  console.log(chalk.blue('   Copying rules...'));
+  try {
+    await copyRules(projectRoot);
+    console.log(chalk.green('   ✓ Copied rules'));
+  } catch (error) {
+    console.log(chalk.yellow('   ⚠ Could not copy rules (package may not have rules)'));
+  }
+
+  // Create lessons.md template
+  const lessonsPath = path.join(claudeDir, 'rules', 'lessons', 'lessons.md');
+  if (!(await fs.exists(lessonsPath))) {
+    const lessonsContent = `# Lessons Learned
+
+## Format
+### YYYY-MM-DD: Lesson Title
+**What happened:** Description
+**Lesson:** What we learned
+**Rule added:** Rule to prevent same mistake
+
+## Recent Lessons
+(No lessons yet - run /retrospect-work after sessions)
+`;
+    await fs.writeFile(lessonsPath, lessonsContent);
+    console.log(chalk.green('   ✓ Created lessons.md'));
+  }
+
+  console.log('');
+  console.log(chalk.green('✅ Project initialized successfully!'));
+  console.log('');
+  console.log(chalk.blue('Next steps:'));
+  console.log(chalk.gray('   1. Add an agent:'));
+  console.log(chalk.cyan('      npx @wipal/agent-team add <name> <role> [options]'));
+  console.log('');
+  console.log(chalk.gray('   2. Or use interactive mode:'));
+  console.log(chalk.cyan('      npx @wipal/agent-team add'));
+  console.log('');
+  console.log(chalk.gray('   3. Available roles: dev-fe, dev-be, sa, tech-lead, devops, pm, qa'));
+}

package/src/commands/list.js

@@ -0,0 +1,66 @@
+/**
+ * List command - List all agents in the project
+ */
+
+import chalk from 'chalk';
+import { isInitialized, getAgents } from '../utils/file-utils.js';
+
+/**
+ * List all agents
+ */
+export async function listCommand() {
+  const projectRoot = process.cwd();
+
+  // Check if initialized
+  if (!(await isInitialized(projectRoot))) {
+    console.log(chalk.yellow('⚠️  Project not initialized'));
+    console.log(chalk.gray('   Run `npx @wipal/agent-team init` first'));
+    return;
+  }
+
+  // Get agents
+  const agents = await getAgents(projectRoot);
+
+  if (agents.length === 0) {
+    console.log(chalk.yellow('📋 No agents found'));
+    console.log('');
+    console.log(chalk.gray('   Create one with:'));
+    console.log(chalk.cyan('   npx @wipal/agent-team add <name> <role>'));
+    return;
+  }
+
+  console.log(chalk.blue(`📋 Agents in project (${agents.length})`));
+  console.log('');
+
+  // Table header
+  console.log(chalk.gray('┌─────────────────┬─────────────┬──────────────────────────────────────┐'));
+  console.log(chalk.gray('│') + chalk.white(' Agent           ') + chalk.gray('│') + chalk.white(' Role        ') + chalk.gray('│') + chalk.white(' Variants                            ') + chalk.gray('│'));
+  console.log(chalk.gray('├─────────────────┼─────────────┼──────────────────────────────────────┤'));
+
+  // Table rows
+  for (const agent of agents) {
+    const name = agent.name.padEnd(15).slice(0, 15);
+    const role = (agent.variants?.base_role || 'unknown').padEnd(11).slice(0, 11);
+
+    // Format variants
+    let variantsStr = '';
+    if (agent.variants?.installed_variants) {
+      const v = Object.entries(agent.variants.installed_variants)
+        .filter(([_, val]) => val)
+        .map(([k, val]) => `${k}=${val}`)
+        .join(', ');
+      variantsStr = v.padEnd(36).slice(0, 36);
+    } else {
+      variantsStr = '(none)'.padEnd(36);
+    }
+
+    console.log(chalk.gray('│') + chalk.cyan(name) + chalk.gray('│') + chalk.yellow(role) + chalk.gray('│') + chalk.gray(variantsStr) + chalk.gray('│'));
+  }
+
+  // Table footer
+  console.log(chalk.gray('└─────────────────┴─────────────┴──────────────────────────────────────┘'));
+
+  console.log('');
+  console.log(chalk.gray('Switch to an agent:'));
+  console.log(chalk.cyan('   npx @wipal/agent-team switch <name>'));
+}

package/src/commands/remove.js

@@ -0,0 +1,71 @@
+/**
+ * Remove command - Remove an agent from the project
+ */
+
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import fs from 'fs-extra';
+import { isInitialized, agentExists, getAgentDir, getAgents } from '../utils/file-utils.js';
+
+/**
+ * Remove an agent
+ */
+export async function removeCommand(name, options) {
+  const projectRoot = process.cwd();
+
+  // Check if initialized
+  if (!(await isInitialized(projectRoot))) {
+    console.log(chalk.red('❌ Project not initialized'));
+    console.log(chalk.gray('   Run `npx @wipal/agent-team init` first'));
+    return;
+  }
+
+  // Check if agent exists
+  if (!(await agentExists(name, projectRoot))) {
+    console.log(chalk.red(`❌ Agent '${name}' not found`));
+    console.log('');
+    console.log(chalk.gray('List available agents:'));
+    console.log(chalk.cyan('   npx @wipal/agent-team list'));
+    return;
+  }
+
+  const agentDir = getAgentDir(name, projectRoot);
+
+  // Confirm deletion unless --force
+  if (!options.force) {
+    console.log(chalk.yellow(`⚠️  This will remove agent '${name}' and all its data`));
+    console.log(chalk.gray(`   Location: ${agentDir}`));
+    console.log('');
+
+    const answer = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'proceed',
+        message: `Remove agent '${name}'?`,
+        default: false
+      }
+    ]);
+
+    if (!answer.proceed) {
+      console.log(chalk.gray('Cancelled.'));
+      return;
+    }
+  }
+
+  // Remove the agent
+  console.log(chalk.blue(`Removing agent '${name}'...`));
+  await fs.remove(agentDir);
+
+  console.log(chalk.green(`✅ Agent '${name}' removed`));
+  console.log('');
+
+  // Show remaining agents
+  const remainingAgents = await getAgents(projectRoot);
+  if (remainingAgents.length > 0) {
+    console.log(chalk.gray(`Remaining agents: ${remainingAgents.length}`));
+    console.log(chalk.cyan('   npx @wipal/agent-team list'));
+  } else {
+    console.log(chalk.gray('No agents remaining'));
+    console.log(chalk.cyan('   npx @wipal/agent-team add <name> <role>'));
+  }
+}

package/src/commands/switch.js

@@ -0,0 +1,53 @@
+/**
+ * Switch command - Show instructions to switch to an agent
+ */
+
+import chalk from 'chalk';
+import { isInitialized, agentExists, getAgentDir } from '../utils/file-utils.js';
+
+/**
+ * Switch to an agent
+ */
+export async function switchCommand(name) {
+  const projectRoot = process.cwd();
+
+  // Check if initialized
+  if (!(await isInitialized(projectRoot))) {
+    console.log(chalk.red('❌ Project not initialized'));
+    console.log(chalk.gray('   Run `npx @wipal/agent-team init` first'));
+    return;
+  }
+
+  // Check if agent exists
+  if (!(await agentExists(name, projectRoot))) {
+    console.log(chalk.red(`❌ Agent '${name}' not found`));
+    console.log('');
+    console.log(chalk.gray('List available agents:'));
+    console.log(chalk.cyan('   npx @wipal/agent-team list'));
+    return;
+  }
+
+  const agentDir = getAgentDir(name, projectRoot);
+  const claudeMdPath = `${agentDir}/CLAUDE.md`;
+
+  console.log(chalk.green(`✓ Switching to agent: ${name}`));
+  console.log('');
+  console.log(chalk.blue('Agent configuration:'));
+  console.log(chalk.gray(`   ${claudeMdPath}`));
+  console.log('');
+  console.log(chalk.blue('How to use in Claude Code:'));
+  console.log('');
+  console.log(chalk.white('Option 1: Use the agent\'s CLAUDE.md directly'));
+  console.log(chalk.gray('   Claude Code will read instructions from:'));
+  console.log(chalk.cyan(`   ${claudeMdPath}`));
+  console.log('');
+  console.log(chalk.white('Option 2: Copy content to project root CLAUDE.md'));
+  console.log(chalk.gray('   If you want this agent to be the default:'));
+  console.log(chalk.cyan(`   cp ${claudeMdPath} .claude/CLAUDE.md`));
+  console.log('');
+  console.log(chalk.white('Option 3: Use /switch command (if available)'));
+  console.log(chalk.cyan(`   /switch ${name}`));
+  console.log('');
+  console.log(chalk.gray('The agent has the following skills available:'));
+  console.log(chalk.gray(`   ${agentDir}/skills/`));
+}

package/src/index.js

@@ -0,0 +1,11 @@
+/**
+ * @wipal/agent-team
+ * Main entry point for programmatic usage
+ */
+
+export { initCommand } from './commands/init.js';
+export { addCommand } from './commands/add.js';
+export { listCommand } from './commands/list.js';
+export { switchCommand } from './commands/switch.js';
+export { removeCommand } from './commands/remove.js';
+export { resolveSkills } from './utils/skill-resolver.js';

package/src/interactive/prompts.js

@@ -0,0 +1,153 @@
+/**
+ * Interactive prompts for agent-team CLI
+ */
+
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import {
+  AVAILABLE_ROLES,
+  VARIANT_CATEGORIES,
+  getVariantsForRole,
+  getAllSkills
+} from '../utils/skill-resolver.js';
+import { createAgent } from '../commands/add.js';
+
+/**
+ * Run interactive add mode
+ */
+export async function runInteractiveAdd(projectRoot, options = {}) {
+  console.log(chalk.blue('🎮 Interactive Mode'));
+  console.log('');
+
+  // Step 1: Agent name
+  const nameAnswer = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'name',
+      message: 'Agent name:',
+      default: options.name || 'my-agent',
+      validate: (input) => {
+        if (!input.trim()) return 'Agent name is required';
+        if (!/^[a-z0-9-]+$/.test(input)) {
+          return 'Use only lowercase letters, numbers, and hyphens';
+        }
+        return true;
+      }
+    }
+  ]);
+
+  // Step 2: Select role
+  const roleAnswer = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'role',
+      message: 'Select role:',
+      choices: AVAILABLE_ROLES.map(r => ({
+        name: `${r.name.padEnd(12)} - ${r.description}`,
+        value: r.name
+      })),
+      default: options.role
+    }
+  ]);
+
+  const selectedRole = roleAnswer.role;
+
+  // Step 3: Select variants based on role
+  const availableVariants = getVariantsForRole(selectedRole);
+  const selectedVariants = {};
+
+  console.log('');
+  console.log(chalk.blue('📦 Select variants (press Enter to skip a category):'));
+  console.log('');
+
+  for (const [category, config] of Object.entries(availableVariants)) {
+    const choices = config.options.map(opt => ({
+      name: opt.label,
+      value: opt.value
+    }));
+
+    // Add "None" option
+    choices.unshift({ name: 'None (skip)', value: null });
+
+    if (config.type === 'select') {
+      const answer = await inquirer.prompt([
+        {
+          type: 'list',
+          name: category,
+          message: `${config.label}:`,
+          choices,
+          default: null
+        }
+      ]);
+
+      if (answer[category]) {
+        selectedVariants[category] = answer[category];
+      }
+    } else if (config.type === 'checkbox') {
+      const answer = await inquirer.prompt([
+        {
+          type: 'checkbox',
+          name: category,
+          message: `${config.label}:`,
+          choices: config.options.map(opt => ({
+            name: opt.label,
+            value: opt.value,
+            checked: false
+          }))
+        }
+      ]);
+
+      if (answer[category] && answer[category].length > 0) {
+        // For checkbox, store as array or join if single
+        selectedVariants[category] = answer[category].join(',');
+      }
+    }
+  }
+
+  // Step 4: Show summary and confirm
+  console.log('');
+  console.log(chalk.cyan('═══════════════════════════════════════════════════════════════'));
+  console.log(chalk.cyan('  Summary'));
+  console.log(chalk.cyan('═══════════════════════════════════════════════════════════════'));
+  console.log('');
+  console.log(chalk.white(`  Agent Name: ${chalk.yellow(nameAnswer.name)}`));
+  console.log(chalk.white(`  Role:       ${chalk.yellow(selectedRole)}`));
+  console.log('');
+
+  // Show selected variants
+  const variantEntries = Object.entries(selectedVariants).filter(([_, v]) => v);
+  if (variantEntries.length > 0) {
+    console.log(chalk.white('  Variants:'));
+    for (const [category, value] of variantEntries) {
+      console.log(chalk.gray(`    - ${category}: ${value}`));
+    }
+  } else {
+    console.log(chalk.gray('  Variants: None'));
+  }
+
+  // Show skills that will be installed
+  const skills = getAllSkills(selectedRole, selectedVariants);
+  console.log('');
+  console.log(chalk.white(`  Skills to install (${skills.length}):`));
+  console.log(chalk.gray(`    ${skills.join(', ')}`));
+
+  console.log('');
+
+  // Confirm
+  const confirmAnswer = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'proceed',
+      message: 'Create this agent?',
+      default: true
+    }
+  ]);
+
+  if (!confirmAnswer.proceed) {
+    console.log(chalk.yellow('Cancelled.'));
+    return;
+  }
+
+  // Create the agent
+  await createAgent(nameAnswer.name, selectedRole, selectedVariants, projectRoot);
+}

package/src/server/api/agents.js

@@ -0,0 +1,150 @@
+/**
+ * Agents API Routes
+ */
+
+import { Router } from 'express';
+import fs from 'fs-extra';
+import path from 'path';
+import {
+  getClaudeDir,
+  getAgentsDir,
+  getAgentDir,
+  isInitialized,
+  agentExists,
+  getAgents
+} from '../../utils/file-utils.js';
+import {
+  resolveSkills,
+  getAllSkills,
+  AVAILABLE_ROLES,
+  VARIANT_CATEGORIES,
+  getVariantsForRole
+} from '../../utils/skill-resolver.js';
+import { createAgent } from '../../commands/add.js';
+
+const router = Router();
+
+/**
+ * List all agents
+ */
+router.get('/', async (req, res) => {
+  try {
+    const projectRoot = req.app.get('projectRoot');
+
+    if (!(await isInitialized(projectRoot))) {
+      return res.json({ initialized: false, agents: [] });
+    }
+
+    const agents = await getAgents(projectRoot);
+    res.json({ initialized: true, agents });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * Get single agent
+ */
+router.get('/:name', async (req, res) => {
+  try {
+    const { name } = req.params;
+    const projectRoot = req.app.get('projectRoot');
+    const agentDir = getAgentDir(name, projectRoot);
+
+    if (!(await fs.exists(agentDir))) {
+      return res.status(404).json({ error: 'Agent not found' });
+    }
+
+    const variants = await fs.readJson(path.join(agentDir, 'variants.json'));
+    const claudeMd = await fs.readFile(path.join(agentDir, 'CLAUDE.md'), 'utf-8');
+
+    // Get skills list
+    const skillsDir = path.join(agentDir, 'skills');
+    let skills = [];
+    if (await fs.exists(skillsDir)) {
+      const skillEntries = await fs.readdir(skillsDir, { withFileTypes: true });
+      skills = skillEntries.filter(e => e.isDirectory()).map(e => e.name);
+    }
+
+    res.json({
+      name,
+      path: agentDir,
+      variants,
+      skills,
+      claudeMd
+    });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * Create new agent
+ */
+router.post('/', async (req, res) => {
+  try {
+    const { name, role, variants } = req.body;
+    const projectRoot = req.app.get('projectRoot');
+
+    if (!(await isInitialized(projectRoot))) {
+      return res.status(400).json({ error: 'Project not initialized' });
+    }
+
+    if (await agentExists(name, projectRoot)) {
+      return res.status(400).json({ error: 'Agent already exists' });
+    }
+
+    await createAgent(name, role, variants || {}, projectRoot);
+
+    res.json({ success: true, name, role });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * Delete agent
+ */
+router.delete('/:name', async (req, res) => {
+  try {
+    const { name } = req.params;
+    const projectRoot = req.app.get('projectRoot');
+    const agentDir = getAgentDir(name, projectRoot);
+
+    if (!(await fs.exists(agentDir))) {
+      return res.status(404).json({ error: 'Agent not found' });
+    }
+
+    await fs.remove(agentDir);
+    res.json({ success: true });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * Get available roles
+ */
+router.get('/meta/roles', (req, res) => {
+  res.json(AVAILABLE_ROLES);
+});
+
+/**
+ * Get available variants for a role
+ */
+router.get('/meta/variants/:role', (req, res) => {
+  const { role } = req.params;
+  const variants = getVariantsForRole(role);
+  res.json(variants);
+});
+
+/**
+ * Preview skills for role + variants
+ */
+router.post('/preview-skills', (req, res) => {
+  const { role, variants } = req.body;
+  const skills = resolveSkills(role, variants || {});
+  res.json(skills);
+});
+
+export default router;