@wipal/agent-team 1.0.4 → 1.1.0

package/src/commands/setup-hooks.js

@@ -0,0 +1,261 @@
+/**
+ * Setup-hooks command - Configure Claude Code hooks
+ */
+
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import inquirer from 'inquirer';
+import { getClaudeDir, isInitialized } from '../utils/file-utils.js';
+
+/**
+ * Setup hooks command handler
+ */
+export async function setupHooksCommand(options) {
+  const projectRoot = process.cwd();
+
+  if (!(await isInitialized(projectRoot))) {
+    console.log(chalk.red('❌ Project not initialized'));
+    console.log(chalk.gray('   Run `npx @wipal/agent-team init` first'));
+    return;
+  }
+
+  if (options.list) {
+    await listHooks();
+    return;
+  }
+
+  if (options.enable) {
+    await enableHook(options.enable, projectRoot);
+    return;
+  }
+
+  if (options.disable) {
+    await disableHook(options.disable, projectRoot);
+    return;
+  }
+
+  // Interactive setup
+  await interactiveSetup(projectRoot, options);
+}
+
+/**
+ * List available hooks
+ */
+async function listHooks() {
+  console.log(chalk.blue('📋 Available Claude Code Hooks'));
+  console.log('');
+
+  const hooks = [
+    {
+      name: 'pre_tool_use',
+      description: 'Runs before any tool is called. Can block tool execution.'
+    },
+    {
+      name: 'post_tool_use',
+      description: 'Runs after a tool call completes. Receives tool result.'
+    },
+    {
+      name: 'notification',
+      description: 'Runs when a notification is triggered.'
+    },
+    {
+      name: 'stop',
+      description: 'Runs when a Claude Code session stops.'
+    }
+  ];
+
+  for (const hook of hooks) {
+    console.log(chalk.cyan(`  ${hook.name}`));
+    console.log(chalk.gray(`    ${hook.description}`));
+    console.log('');
+  }
+
+  console.log(chalk.gray('Usage:'));
+  console.log(chalk.cyan('  npx @wipal/agent-team setup-hooks --enable pre_tool_use'));
+  console.log(chalk.cyan('  npx @wipal/agent-team setup-hooks --disable post_tool_use'));
+}
+
+/**
+ * Enable a specific hook
+ */
+async function enableHook(hookName, projectRoot) {
+  const claudeDir = getClaudeDir(projectRoot);
+  const hooksDir = path.join(claudeDir, 'hooks');
+  const settingsPath = path.join(claudeDir, 'settings.json');
+
+  const validHooks = ['pre_tool_use', 'post_tool_use', 'notification', 'stop'];
+  if (!validHooks.includes(hookName)) {
+    console.log(chalk.red(`❌ Invalid hook: ${hookName}`));
+    console.log(chalk.gray(`   Valid hooks: ${validHooks.join(', ')}`));
+    return;
+  }
+
+  await fs.ensureDir(hooksDir);
+
+  // Create hook script
+  const hookScript = getHookScript(hookName);
+  const hookPath = path.join(hooksDir, `${hookName}.sh`);
+  await fs.writeFile(hookPath, hookScript);
+  await fs.chmod(hookPath, '755');
+
+  // Update settings.json
+  let settings = {};
+  if (await fs.exists(settingsPath)) {
+    settings = await fs.readJson(settingsPath);
+  }
+
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+
+  settings.hooks[hookName] = {
+    command: `.claude/hooks/${hookName}.sh`,
+    enabled: true
+  };
+
+  await fs.writeJson(settingsPath, settings, { spaces: 2 });
+
+  console.log(chalk.green(`✓ Enabled hook: ${hookName}`));
+}
+
+/**
+ * Disable a specific hook
+ */
+async function disableHook(hookName, projectRoot) {
+  const claudeDir = getClaudeDir(projectRoot);
+  const settingsPath = path.join(claudeDir, 'settings.json');
+
+  if (!(await fs.exists(settingsPath))) {
+    console.log(chalk.yellow('⚠ No settings.json found'));
+    return;
+  }
+
+  const settings = await fs.readJson(settingsPath);
+
+  if (settings.hooks && settings.hooks[hookName]) {
+    settings.hooks[hookName].enabled = false;
+    await fs.writeJson(settingsPath, settings, { spaces: 2 });
+    console.log(chalk.green(`✓ Disabled hook: ${hookName}`));
+  } else {
+    console.log(chalk.yellow(`⚠ Hook ${hookName} is not configured`));
+  }
+}
+
+/**
+ * Interactive hooks setup
+ */
+async function interactiveSetup(projectRoot, options) {
+  const claudeDir = getClaudeDir(projectRoot);
+
+  console.log(chalk.blue('🔧 Claude Code Hooks Setup'));
+  console.log('');
+
+  const answer = await inquirer.prompt([
+    {
+      type: 'checkbox',
+      name: 'hooks',
+      message: 'Select hooks to enable:',
+      choices: [
+        { name: 'pre_tool_use - Before any tool call', value: 'pre_tool_use', checked: true },
+        { name: 'post_tool_use - After tool call completes', value: 'post_tool_use', checked: true },
+        { name: 'notification - When notification triggered', value: 'notification', checked: false },
+        { name: 'stop - When session stops', value: 'stop', checked: true }
+      ]
+    }
+  ]);
+
+  if (answer.hooks.length === 0) {
+    console.log(chalk.yellow('No hooks selected'));
+    return;
+  }
+
+  const hooksDir = path.join(claudeDir, 'hooks');
+  await fs.ensureDir(hooksDir);
+
+  for (const hookName of answer.hooks) {
+    const hookScript = getHookScript(hookName);
+    const hookPath = path.join(hooksDir, `${hookName}.sh`);
+    await fs.writeFile(hookPath, hookScript);
+    await fs.chmod(hookPath, '755');
+    console.log(chalk.green(`   ✓ Created hook: ${hookName}.sh`));
+  }
+
+  // Update settings.json
+  const settingsPath = path.join(claudeDir, 'settings.json');
+  let settings = {};
+
+  if (await fs.exists(settingsPath)) {
+    settings = await fs.readJson(settingsPath);
+  }
+
+  settings.hooks = {};
+  for (const hookName of answer.hooks) {
+    settings.hooks[hookName] = {
+      command: `.claude/hooks/${hookName}.sh`,
+      enabled: true
+    };
+  }
+
+  await fs.writeJson(settingsPath, settings, { spaces: 2 });
+  console.log(chalk.green('   ✓ Updated settings.json with hooks configuration'));
+
+  console.log('');
+  console.log(chalk.green('✅ Hooks setup complete!'));
+}
+
+/**
+ * Get hook script content
+ */
+function getHookScript(hookName) {
+  const scripts = {
+    pre_tool_use: `#!/bin/bash
+# Pre-tool-use hook for agent-team
+# This runs before any tool is called
+
+# Read stdin for tool info
+read -r TOOL_INFO
+
+# Log tool usage (optional)
+# echo "Tool call: $TOOL_INFO" >> ~/.agent-team/logs/tool-usage.log
+
+# Return 0 to allow tool, non-zero to block
+exit 0
+`,
+    post_tool_use: `#!/bin/bash
+# Post-tool-use hook for agent-team
+# This runs after a tool call completes
+
+# Read stdin for result info
+read -r TOOL_RESULT
+
+# Log tool result (optional)
+# echo "Tool result: $TOOL_RESULT" >> ~/.agent-team/logs/tool-usage.log
+
+exit 0
+`,
+    notification: `#!/bin/bash
+# Notification hook for agent-team
+# This runs when a notification is triggered
+
+# Read notification content
+read -r NOTIFICATION
+
+# You can add custom notification handling here
+# e.g., send to Slack, Discord, etc.
+
+exit 0
+`,
+    stop: `#!/bin/bash
+# Stop hook for agent-team
+# This runs when a session stops
+
+# You can add cleanup or summary logic here
+# e.g., save session state, generate summary
+
+exit 0
+`
+  };
+
+  return scripts[hookName] || '';
+}

package/src/index.js

@@ -6,6 +6,5 @@
 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/utils/file-utils.js

@@ -39,12 +39,26 @@ export function getAgentsDir(projectRoot = getProjectRoot()) {
 }
 
 /**
- * Get specific agent directory path
+ * Get specific agent directory path (legacy - for backward compatibility)
  */
 export function getAgentDir(agentName, projectRoot = getProjectRoot()) {
   return path.join(getAgentsDir(projectRoot), agentName);
 }
 
+/**
+ * Get agent file path (new format: .claude/agents/<name>.md)
+ */
+export function getAgentFilePath(agentName, projectRoot = getProjectRoot()) {
+  return path.join(getAgentsDir(projectRoot), `${agentName}.md`);
+}
+
+/**
+ * Get agent memory directory path (.claude/agent-memory/<name>/)
+ */
+export function getAgentMemoryDir(agentName, projectRoot = getProjectRoot()) {
+  return path.join(getClaudeDir(projectRoot), 'agent-memory', agentName);
+}
+
 /**
  * Check if .claude directory exists
  */
@@ -53,9 +67,15 @@ export async function isInitialized(projectRoot = getProjectRoot()) {
 }
 
 /**
- * Check if agent exists
+ * Check if agent exists (checks for .md file)
  */
 export async function agentExists(agentName, projectRoot = getProjectRoot()) {
+  // Check for new format (.md file)
+  const agentFile = getAgentFilePath(agentName, projectRoot);
+  if (await fs.exists(agentFile)) {
+    return true;
+  }
+  // Also check for legacy format (directory)
   return fs.exists(getAgentDir(agentName, projectRoot));
 }
 
@@ -73,7 +93,46 @@ export async function getAgents(projectRoot = getProjectRoot()) {
   const agents = [];
 
   for (const entry of entries) {
-    if (entry.isDirectory()) {
+    // New format: .md files
+    if (entry.isFile() && entry.name.endsWith('.md')) {
+      const agentName = entry.name.replace('.md', '');
+      const agentPath = path.join(agentsDir, entry.name);
+
+      // Parse frontmatter to get metadata
+      let metadata = { name: agentName, description: '', skills: [] };
+      try {
+        const content = await fs.readFile(agentPath, 'utf-8');
+        const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+        if (frontmatterMatch) {
+          const frontmatter = frontmatterMatch[1];
+          // Parse simple YAML fields
+          const nameMatch = frontmatter.match(/^name:\s*(.+)$/m);
+          const descMatch = frontmatter.match(/^description:\s*(.+)$/m);
+          const skillsMatch = frontmatter.match(/^skills:\s*\n((?:  - .+\n?)+)/m);
+
+          if (nameMatch) metadata.name = nameMatch[1].trim();
+          if (descMatch) metadata.description = descMatch[1].trim();
+          if (skillsMatch) {
+            metadata.skills = skillsMatch[1]
+              .split('\n')
+              .filter(line => line.trim().startsWith('-'))
+              .map(line => line.replace(/^\s*-\s*/, '').trim());
+          }
+        }
+      } catch (e) {
+        // Ignore parse errors
+      }
+
+      agents.push({
+        name: agentName,
+        path: agentPath,
+        format: 'new',
+        description: metadata.description,
+        skills: metadata.skills
+      });
+    }
+    // Legacy format: directories
+    else if (entry.isDirectory()) {
       const agentDir = path.join(agentsDir, entry.name);
       const variantsPath = path.join(agentDir, 'variants.json');
       const skillsDir = path.join(agentDir, 'skills');
@@ -103,6 +162,7 @@ export async function getAgents(projectRoot = getProjectRoot()) {
       agents.push({
         name: entry.name,
         path: agentDir,
+        format: 'legacy',
         variants,
         skills
       });
@@ -113,61 +173,85 @@ export async function getAgents(projectRoot = getProjectRoot()) {
 }
 
 /**
- * Copy skills from package to agent folder
- */
-export async function copySkills(skillNames, targetDir, sourceDir = null) {
-  const skillsSourceDir = sourceDir || path.join(PACKAGE_ROOT, '.claude', 'skills');
-  const targetSkillsDir = path.join(targetDir, 'skills');
-
-  await fs.ensureDir(targetSkillsDir);
-
-  const copiedSkills = [];
-
-  for (const skillName of skillNames) {
-    // Find skill in various locations
-    const possiblePaths = [
-      // Core skills
-      path.join(skillsSourceDir, 'core', skillName),
-      // Domain skills - frontend
-      path.join(skillsSourceDir, 'domain', 'frontend', skillName),
-      // Domain skills - backend
-      path.join(skillsSourceDir, 'domain', 'backend', skillName),
-      // Domain skills - architecture
-      path.join(skillsSourceDir, 'domain', 'architecture', skillName),
-      // Domain skills - devops
-      path.join(skillsSourceDir, 'domain', 'devops', skillName),
-      // Domain skills - product
-      path.join(skillsSourceDir, 'domain', 'product', skillName),
-      // Domain skills - quality
-      path.join(skillsSourceDir, 'domain', 'quality', skillName),
-      // Leadership skills
-      path.join(skillsSourceDir, 'leadership', skillName),
-      // Community skills
-      path.join(skillsSourceDir, 'community', skillName),
-    ];
-
-    for (const skillPath of possiblePaths) {
-      if (await fs.exists(skillPath)) {
-        const targetPath = path.join(targetSkillsDir, skillName);
-        await fs.copy(skillPath, targetPath);
-        copiedSkills.push(skillName);
-        break;
-      }
-    }
+ * Copy rules from package to project
+ * @param {string} projectRoot - Project root directory
+ * @param {Object} options - Options for copying
+ * @param {string[]} options.includeRoleRules - List of roles to copy rules for
+ * @param {boolean} options.overwrite - Whether to overwrite existing files
+ */
+export async function copyRules(projectRoot = getProjectRoot(), options = {}) {
+  const { includeRoleRules = [], overwrite = false } = options;
+  const rulesSourceDir = path.join(PACKAGE_ROOT, '.claude', 'rules');
+  const targetRulesDir = path.join(getClaudeDir(projectRoot), 'rules');
+
+  await fs.ensureDir(targetRulesDir);
+
+  // Always copy common rules
+  const commonSourceDir = path.join(rulesSourceDir, 'common');
+  const commonTargetDir = path.join(targetRulesDir, 'common');
+  if (await fs.exists(commonSourceDir)) {
+    await fs.copy(commonSourceDir, commonTargetDir, { overwrite });
   }
 
-  return copiedSkills;
+  // Always ensure lessons directory exists and copy template if not present
+  const lessonsSourceDir = path.join(rulesSourceDir, 'lessons');
+  const lessonsTargetDir = path.join(targetRulesDir, 'lessons');
+  await fs.ensureDir(lessonsTargetDir);
+
+  const lessonsTemplate = path.join(lessonsSourceDir, 'lessons.md');
+  const lessonsTarget = path.join(lessonsTargetDir, 'lessons.md');
+  if (await fs.exists(lessonsTemplate) && (!(await fs.exists(lessonsTarget)) || overwrite)) {
+    await fs.copy(lessonsTemplate, lessonsTarget);
+  }
+
+  // Create role-rules directory (empty by default)
+  const roleRulesTargetDir = path.join(targetRulesDir, 'role-rules');
+  await fs.ensureDir(roleRulesTargetDir);
+
+  // Only copy specific role rules if requested
+  for (const role of includeRoleRules) {
+    const roleRuleFile = `${role}-rules.md`;
+    const roleRuleSource = path.join(rulesSourceDir, 'role-rules', roleRuleFile);
+    const roleRuleTarget = path.join(roleRulesTargetDir, roleRuleFile);
+    if (await fs.exists(roleRuleSource)) {
+      await fs.copy(roleRuleSource, roleRuleTarget, { overwrite });
+    }
+  }
 }
 
 /**
- * Copy rules from package to project
+ * Copy role-specific rules when adding agent
+ * @param {string} role - Role name (e.g., 'dev-fe', 'sa')
+ * @param {string} projectRoot - Project root directory
+ * @returns {string|null} - Name of copied file or null if not copied
  */
-export async function copyRules(projectRoot = getProjectRoot()) {
-  const rulesSourceDir = path.join(PACKAGE_ROOT, '.claude', 'rules');
-  const targetRulesDir = path.join(getClaudeDir(projectRoot), 'rules');
+export async function copyRoleRules(role, projectRoot = getProjectRoot()) {
+  const rulesSourceDir = path.join(PACKAGE_ROOT, '.claude', 'rules', 'role-rules');
+  const targetRulesDir = path.join(getClaudeDir(projectRoot), 'rules', 'role-rules');
 
   await fs.ensureDir(targetRulesDir);
-  await fs.copy(rulesSourceDir, targetRulesDir, { overwrite: false });
+
+  // Map role to rule file
+  const roleRuleMap = {
+    'dev-fe': 'dev-fe-rules.md',
+    'sa': 'sa-rules.md',
+    'dev-be': 'dev-be-rules.md',
+    'tech-lead': 'tech-lead-rules.md',
+    'devops': 'devops-rules.md',
+    'pm': 'pm-rules.md',
+    'qa': 'qa-rules.md'
+  };
+
+  const ruleFile = roleRuleMap[role];
+  if (ruleFile) {
+    const source = path.join(rulesSourceDir, ruleFile);
+    const target = path.join(targetRulesDir, ruleFile);
+    if (await fs.exists(source) && !(await fs.exists(target))) {
+      await fs.copy(source, target);
+      return ruleFile;
+    }
+  }
+  return null;
 }
 
 /**
@@ -191,3 +275,16 @@ export function processTemplate(template, variables) {
 
   return result;
 }
+
+/**
+ * Read role behavioral template
+ * @param {string} role - Role name (e.g., 'dev-fe', 'sa')
+ * @returns {string|null} - Template content or null if not found
+ */
+export async function readRoleTemplate(role) {
+  const templatePath = path.join(PACKAGE_ROOT, 'templates', 'roles', `${role}.md`);
+  if (await fs.exists(templatePath)) {
+    return fs.readFile(templatePath, 'utf-8');
+  }
+  return null;
+}