@patricio0312rev/agentkit 0.1.0

package/src/commands/init.js

@@ -0,0 +1,312 @@
+const inquirer = require("inquirer");
+const chalk = require("chalk");
+const ora = require("ora");
+const { generateAgents } = require("../lib/generator");
+const { TOOLS, DEPARTMENTS } = require("../lib/config");
+const { displayError, displayBox } = require("../utils/display");
+
+async function initCommand(options) {
+  console.log(chalk.cyan("\n🚀 Let's set up your AI agents!\n"));
+
+  try {
+    let config = {};
+
+    // Check if all required options provided (non-interactive mode)
+    if (options.skipPrompts) {
+      if (!options.tool || !options.departments) {
+        displayError("--skip-prompts requires --tool and --departments flags");
+        process.exit(1);
+      }
+      config = buildConfigFromFlags(options);
+    } else {
+      // Interactive mode
+      config = await promptUser(options);
+    }
+
+    // Validate configuration
+    const validation = validateConfiguration(config);
+    if (!validation.isValid) {
+      displayError("Configuration validation failed:");
+      validation.errors.forEach((err) => console.log(chalk.red(`  • ${err}`)));
+      process.exit(1);
+    }
+
+    // Generate the configuration
+    await generateConfiguration(config);
+  } catch (error) {
+    displayError(`Failed to initialize: ${error.message}`);
+    if (process.env.DEBUG) {
+      console.error(error);
+    }
+    process.exit(1);
+  }
+}
+
+function buildConfigFromFlags(options) {
+  return {
+    tool: options.tool,
+    folder: options.folder || TOOLS[options.tool]?.folder || ".ai",
+    departments: options.departments.split(",").map((d) => d.trim()),
+    agents: options.agents
+      ? options.agents.split(",").map((a) => a.trim())
+      : [],
+    stack: [], // Removed for v0.1.0
+  };
+}
+
+async function promptUser(options) {
+  const answers = {};
+
+  // Step 1: Select AI tool
+  if (!options.tool) {
+    const toolChoices = Object.entries(TOOLS).map(([key, value]) => ({
+      name: `${chalk.bold(value.name)} ${chalk.dim("→")} ${chalk.gray(value.description)}`,
+      value: key,
+      short: value.name,
+    }));
+
+    const toolAnswer = await inquirer.prompt([
+      {
+        type: "list",
+        name: "tool",
+        message: "Which AI tool are you using?",
+        choices: toolChoices,
+        default: "cursor",
+      },
+    ]);
+    answers.tool = toolAnswer.tool;
+  } else {
+    answers.tool = options.tool;
+  }
+
+  // Step 2: Custom folder name
+  const defaultFolder = TOOLS[answers.tool].folder;
+  if (!options.folder) {
+    const folderAnswer = await inquirer.prompt([
+      {
+        type: "input",
+        name: "folder",
+        message: "Folder name for AI agents:",
+        default: defaultFolder,
+        validate: (input) => {
+          if (!input.trim()) return "Folder name cannot be empty";
+          if (input.includes(" ")) return "Folder name cannot contain spaces";
+          if (input.includes("\\") || input.includes("/"))
+            return "Folder name cannot contain path separators";
+          return true;
+        },
+      },
+    ]);
+    answers.folder = folderAnswer.folder;
+  } else {
+    answers.folder = options.folder;
+  }
+
+  // Step 3: Select departments
+  if (!options.departments) {
+    const deptChoices = Object.entries(DEPARTMENTS).map(([key, value]) => ({
+      name: `${chalk.bold(value.name)} ${chalk.dim(`(${value.agents.length} agents)`)} ${chalk.gray("→ " + value.description)}`,
+      value: key,
+      short: value.name,
+      checked: ["engineering", "design"].includes(key), // Default selections
+    }));
+
+    const deptAnswer = await inquirer.prompt([
+      {
+        type: "checkbox",
+        name: "departments",
+        message: "Select departments to include:",
+        choices: deptChoices,
+        pageSize: 10,
+        validate: (input) => {
+          if (input.length === 0)
+            return "Please select at least one department";
+          return true;
+        },
+      },
+    ]);
+    answers.departments = deptAnswer.departments;
+  } else {
+    answers.departments = options.departments.split(",").map((d) => d.trim());
+  }
+
+  // Step 4: Select specific agents per department
+  answers.agents = [];
+
+  if (!options.agents) {
+    console.log(chalk.cyan("\n📋 Select agents for each department:\n"));
+
+    for (const dept of answers.departments) {
+      const deptInfo = DEPARTMENTS[dept];
+
+      const agentChoices = deptInfo.agents.map((agent) => ({
+        name: agent,
+        value: `${dept}/${agent}`,
+        checked: true, // All selected by default
+      }));
+
+      const agentAnswer = await inquirer.prompt([
+        {
+          type: "checkbox",
+          name: "selectedAgents",
+          message: `${chalk.bold(deptInfo.name)} agents:`,
+          choices: agentChoices,
+          pageSize: 15,
+          validate: (input) => {
+            if (input.length === 0) {
+              return `Please select at least one agent from ${deptInfo.name} (or deselect the department)`;
+            }
+            return true;
+          },
+        },
+      ]);
+
+      answers.agents.push(...agentAnswer.selectedAgents);
+    }
+  } else {
+    answers.agents = options.agents.split(",").map((a) => a.trim());
+  }
+
+  // Count total agents selected
+  const totalAgents = answers.agents.length;
+  console.log(
+    chalk.dim(`\n  → Total agents selected: ${chalk.bold(totalAgents)}\n`)
+  );
+
+  answers.stack = []; // Removed for v0.1.0
+
+  return answers;
+}
+
+function validateConfiguration(config) {
+  const errors = [];
+
+  // Validate tool
+  if (!config.tool || !TOOLS[config.tool]) {
+    errors.push(
+      `Invalid tool: ${config.tool}. Valid options: ${Object.keys(TOOLS).join(", ")}`
+    );
+  }
+
+  // Validate folder
+  if (!config.folder || typeof config.folder !== "string") {
+    errors.push("Folder name is required and must be a string");
+  }
+
+  // Validate departments
+  if (
+    !config.departments ||
+    !Array.isArray(config.departments) ||
+    config.departments.length === 0
+  ) {
+    errors.push("At least one department is required");
+  }
+
+  config.departments?.forEach((dept) => {
+    if (!DEPARTMENTS[dept]) {
+      errors.push(
+        `Invalid department: ${dept}. Valid options: ${Object.keys(DEPARTMENTS).join(", ")}`
+      );
+    }
+  });
+
+  return {
+    isValid: errors.length === 0,
+    errors,
+  };
+}
+
+async function generateConfiguration(config) {
+  const spinner = ora("Generating AI agent configuration...").start();
+
+  try {
+    const result = await generateAgents(config);
+
+    spinner.succeed(chalk.green("✓ Configuration generated successfully!"));
+
+    // Display results
+    displayResults(config, result);
+  } catch (error) {
+    spinner.fail(chalk.red("Failed to generate configuration"));
+    throw error;
+  }
+}
+
+function displayResults(config, result) {
+  const tool = TOOLS[config.tool];
+
+  // Format file location with proper coloring
+  const locationLine = `Location: ${chalk.yellow(config.folder + "/")}`;
+  const toolLine = `Tool: ${chalk.cyan(tool.name)}`;
+  const deptLine = `Departments: ${config.departments.length}`;
+  const agentsLine = `Agents: ${result.agentsGenerated || 0}`;
+
+  displayBox(
+    "📁 Generated Files",
+    `${locationLine}\n${toolLine}\n${deptLine}\n${agentsLine}`
+  );
+
+  displayBox("📚 Usage Instructions", getUsageInstructions(config.tool));
+
+  const step1 = `1. Review files in ${chalk.yellow(config.folder + "/")}`;
+  const step2 = `2. Read ${chalk.yellow(config.folder + "/README.md")}`;
+  const step3 = `3. ${getToolSpecificNextStep(config.tool)}`;
+  const step4 = `4. Commit to version control to share with team`;
+
+  displayBox("🚀 Next Steps", `${step1}\n${step2}\n${step3}\n${step4}`);
+
+  console.log(
+    chalk.dim("💡 Tip: Run ") +
+      chalk.cyan("agentkit init") +
+      chalk.dim(" again to regenerate\n")
+  );
+}
+
+function getUsageInstructions(tool) {
+  const instructions = {
+    "claude-code":
+      `With Claude Code CLI:\n` +
+      chalk.gray("  $ ") +
+      chalk.green('claude-code "Build login page using frontend-developer"\n') +
+      `\n` +
+      `Agents will be automatically loaded by Claude Code.`,
+
+    cursor:
+      `With Cursor:\n` +
+      `1. Use @-mentions in chat:\n` +
+      chalk.gray("     @engineering/backend-architect.md ") +
+      chalk.dim("Design API\n") +
+      `2. Or reference in prompts naturally`,
+
+    copilot:
+      `With GitHub Copilot:\n` +
+      `Instructions are in .github/copilot-instructions.md\n` +
+      `Copilot will automatically use them.`,
+
+    aider:
+      `With Aider:\n` +
+      `Conventions are in .aider/conventions.md\n` +
+      `Aider will use them automatically.`,
+
+    universal:
+      `With any AI tool:\n` +
+      `Upload relevant agent .md files to your AI chat\n` +
+      `and reference them in your prompts.`,
+  };
+
+  return instructions[tool] || instructions.universal;
+}
+
+function getToolSpecificNextStep(tool) {
+  const steps = {
+    "claude-code": "Start coding: " + chalk.green('claude-code "your task"'),
+    cursor: "Open Cursor and use @-mentions",
+    copilot: "Start coding - Copilot will use the instructions",
+    aider: "Start coding: " + chalk.green("aider --read .aider/"),
+    universal: "Open your AI tool and upload the agent files",
+  };
+
+  return steps[tool] || steps.universal;
+}
+
+module.exports = initCommand;

package/src/index.js

@@ -0,0 +1,220 @@
+/**
+ * AgentKit - Programmatic API
+ * 
+ * This module exports the main functions for use by:
+ * - CLI (this package)
+ * - VSCode Extension
+ * - Other integrations
+ */
+
+const { generateAgents } = require('./lib/generator');
+const { TOOLS, DEPARTMENTS, STACKS } = require('./lib/config');
+
+/**
+ * Generate AI agent configuration programmatically
+ * @param {Object} config - Configuration object
+ * @param {string} config.tool - AI tool (claude-code, cursor, copilot, aider, universal)
+ * @param {string} config.folder - Target folder name
+ * @param {string[]} config.departments - List of departments to include
+ * @param {string[]} [config.agents] - Optional: specific agents to include
+ * @param {string[]} [config.stack] - Optional: tech stack
+ * @param {boolean} [config.skipExamples] - Skip examples in agent files
+ * @returns {Promise<Object>} Result object with success status and details
+ * 
+ * @example
+ * const agentkit = require('agentkit');
+ * 
+ * const result = await agentkit.generate({
+ *   tool: 'cursor',
+ *   folder: '.cursorrules',
+ *   departments: ['engineering', 'design'],
+ *   stack: ['react', 'typescript', 'nodejs']
+ * });
+ * 
+ * console.log(`Generated ${result.agentsGenerated} agents`);
+ */
+async function generate(config) {
+  // Validate config
+  const validation = validateConfig(config);
+  if (!validation.isValid) {
+    throw new Error(`Invalid configuration: ${validation.errors.join(', ')}`);
+  }
+
+  return await generateAgents(config);
+}
+
+/**
+ * Get list of available tools
+ * @returns {Object} Tools configuration
+ * 
+ * @example
+ * const tools = agentkit.getTools();
+ * console.log(Object.keys(tools)); // ['claude-code', 'cursor', 'copilot', ...]
+ */
+function getTools() {
+  return { ...TOOLS };
+}
+
+/**
+ * Get list of available departments
+ * @returns {Object} Departments configuration
+ * 
+ * @example
+ * const departments = agentkit.getDepartments();
+ * console.log(departments.engineering.agents); // ['ai-engineer', 'backend-architect', ...]
+ */
+function getDepartments() {
+  return { ...DEPARTMENTS };
+}
+
+/**
+ * Get list of available tech stacks
+ * @returns {Object} Tech stack configuration
+ */
+function getStacks() {
+  return { ...STACKS };
+}
+
+/**
+ * Get agents for a specific department
+ * @param {string} department - Department name
+ * @returns {string[]} List of agent names
+ * 
+ * @example
+ * const agents = agentkit.getAgentsForDepartment('engineering');
+ * console.log(agents); // ['ai-engineer', 'backend-architect', ...]
+ */
+function getAgentsForDepartment(department) {
+  return DEPARTMENTS[department]?.agents || [];
+}
+
+/**
+ * Get all available agents across all departments
+ * @returns {Object} Object with department as key and agents array as value
+ * 
+ * @example
+ * const allAgents = agentkit.getAllAgents();
+ * console.log(allAgents.engineering); // ['ai-engineer', 'backend-architect', ...]
+ */
+function getAllAgents() {
+  const result = {};
+  Object.entries(DEPARTMENTS).forEach(([dept, info]) => {
+    result[dept] = [...info.agents];
+  });
+  return result;
+}
+
+/**
+ * Validate configuration
+ * @param {Object} config - Configuration to validate
+ * @returns {Object} Validation result with isValid and errors
+ * 
+ * @example
+ * const validation = agentkit.validateConfig({
+ *   tool: 'cursor',
+ *   folder: '.cursorrules',
+ *   departments: ['engineering']
+ * });
+ * 
+ * if (!validation.isValid) {
+ *   console.error(validation.errors);
+ * }
+ */
+function validateConfig(config) {
+  const errors = [];
+
+  // Validate tool
+  if (!config.tool) {
+    errors.push('Tool is required');
+  } else if (!TOOLS[config.tool]) {
+    errors.push(`Invalid tool: ${config.tool}. Valid options: ${Object.keys(TOOLS).join(', ')}`);
+  }
+
+  // Validate folder
+  if (!config.folder) {
+    errors.push('Folder is required');
+  } else if (typeof config.folder !== 'string') {
+    errors.push('Folder must be a string');
+  } else if (config.folder.includes(' ')) {
+    errors.push('Folder name cannot contain spaces');
+  }
+
+  // Validate departments
+  if (!config.departments) {
+    errors.push('Departments are required');
+  } else if (!Array.isArray(config.departments)) {
+    errors.push('Departments must be an array');
+  } else if (config.departments.length === 0) {
+    errors.push('At least one department is required');
+  } else {
+    config.departments.forEach(dept => {
+      if (!DEPARTMENTS[dept]) {
+        errors.push(`Invalid department: ${dept}. Valid options: ${Object.keys(DEPARTMENTS).join(', ')}`);
+      }
+    });
+  }
+
+  // Validate agents if provided
+  if (config.agents && !Array.isArray(config.agents)) {
+    errors.push('Agents must be an array');
+  }
+
+  // Validate stack if provided
+  if (config.stack && !Array.isArray(config.stack)) {
+    errors.push('Stack must be an array');
+  }
+
+  return {
+    isValid: errors.length === 0,
+    errors
+  };
+}
+
+/**
+ * Get recommended configuration based on project type
+ * @param {string} projectType - Type of project (web, mobile, fullstack, etc.)
+ * @returns {Object} Recommended configuration
+ * 
+ * @example
+ * const config = agentkit.getRecommendedConfig('web');
+ * // Returns recommended departments and stack for web projects
+ */
+function getRecommendedConfig(projectType) {
+  const recommendations = {
+    web: {
+      departments: ['engineering', 'design', 'testing'],
+      stack: ['react', 'typescript', 'nodejs']
+    },
+    mobile: {
+      departments: ['engineering', 'design', 'testing'],
+      stack: ['react-native', 'typescript']
+    },
+    fullstack: {
+      departments: ['engineering', 'design', 'product', 'testing'],
+      stack: ['react', 'nodejs', 'postgres', 'typescript']
+    },
+    startup: {
+      departments: ['engineering', 'design', 'product', 'marketing'],
+      stack: ['react', 'nodejs', 'postgres']
+    }
+  };
+
+  return recommendations[projectType] || recommendations.web;
+}
+
+// Export all functions
+module.exports = {
+  generate,
+  getTools,
+  getDepartments,
+  getStacks,
+  getAgentsForDepartment,
+  getAllAgents,
+  validateConfig,
+  getRecommendedConfig,
+  
+  // Also export config directly for convenience
+  TOOLS,
+  DEPARTMENTS,
+  STACKS
+};

package/src/lib/config.js

@@ -0,0 +1,157 @@
+const TOOLS = {
+    'claude-code': {
+      name: 'Claude Code',
+      folder: '.claude',
+      description: 'Sub-agents with native support',
+      fileStructure: 'multi-file',
+      supportsSubAgents: true
+    },
+    'cursor': {
+      name: 'Cursor',
+      folder: '.cursorrules',
+      description: 'Single .cursorrules file or @-mention files',
+      fileStructure: 'multi-file',
+      supportsSubAgents: true
+    },
+    'copilot': {
+      name: 'GitHub Copilot',
+      folder: '.github',
+      description: '.github/copilot-instructions.md',
+      fileStructure: 'single-file',
+      supportsSubAgents: false
+    },
+    'aider': {
+      name: 'Aider',
+      folder: '.aider',
+      description: 'Aider conventions.md',
+      fileStructure: 'single-file',
+      supportsSubAgents: false
+    },
+    'universal': {
+      name: 'Universal',
+      folder: '.ai',
+      description: 'Works with any tool',
+      fileStructure: 'multi-file',
+      supportsSubAgents: true
+    }
+};
+  
+const DEPARTMENTS = {
+    design: {
+      name: 'Design',
+      description: 'Visual design, UX research, and brand management',
+      agents: [
+        'brand-guardian',
+        'ui-designer',
+        'ux-researcher',
+        'visual-storyteller',
+        'whimsy-injector'
+      ]
+    },
+    engineering: {
+      name: 'Engineering',
+      description: 'Software development, architecture, and DevOps',
+      agents: [
+        'ai-engineer',
+        'backend-architect',
+        'devops-automator',
+        'frontend-developer',
+        'mobile-app-builder',
+        'rapid-prototyper',
+        'test-writer-fixer'
+      ]
+    },
+    marketing: {
+      name: 'Marketing',
+      description: 'Growth, content creation, and social media',
+      agents: [
+        'app-store-optimizer',
+        'content-creator',
+        'growth-hacker',
+        'instagram-curator',
+        'reddit-community-builder',
+        'tiktok-strategist',
+        'twitter-engager'
+      ]
+    },
+    product: {
+      name: 'Product',
+      description: 'Product management, user feedback, and trends',
+      agents: [
+        'feedback-synthesizer',
+        'sprint-prioritizer',
+        'trend-researcher'
+      ]
+    },
+    'project-management': {
+      name: 'Project Management',
+      description: 'Sprint planning, experiments, and launches',
+      agents: [
+        'experiment-tracker',
+        'project-shipper',
+        'studio-producer'
+      ]
+    },
+    'studio-operations': {
+      name: 'Studio Operations',
+      description: 'Analytics, finance, infrastructure, and support',
+      agents: [
+        'analytics-reporter',
+        'finance-tracker',
+        'infrastructure-maintainer',
+        'legal-compliance-checker',
+        'support-responder'
+      ]
+    },
+    testing: {
+      name: 'Testing',
+      description: 'Quality assurance, performance, and testing',
+      agents: [
+        'api-tester',
+        'performance-benchmarker',
+        'test-results-analyzer',
+        'tool-evaluator',
+        'workflow-optimizer'
+      ]
+    }
+  };
+  
+  const STACKS = {
+    // Frontend
+    react: { name: 'React', category: 'frontend' },
+    vue: { name: 'Vue', category: 'frontend' },
+    angular: { name: 'Angular', category: 'frontend' },
+    svelte: { name: 'Svelte', category: 'frontend' },
+    nextjs: { name: 'Next.js', category: 'frontend' },
+    
+    // Backend
+    nodejs: { name: 'Node.js', category: 'backend' },
+    python: { name: 'Python', category: 'backend' },
+    go: { name: 'Go', category: 'backend' },
+    rust: { name: 'Rust', category: 'backend' },
+    java: { name: 'Java', category: 'backend' },
+    
+    // Database
+    postgres: { name: 'PostgreSQL', category: 'database' },
+    mongodb: { name: 'MongoDB', category: 'database' },
+    mysql: { name: 'MySQL', category: 'database' },
+    redis: { name: 'Redis', category: 'database' },
+    
+    // Cloud/Infrastructure
+    aws: { name: 'AWS', category: 'cloud' },
+    gcp: { name: 'Google Cloud', category: 'cloud' },
+    azure: { name: 'Azure', category: 'cloud' },
+    vercel: { name: 'Vercel', category: 'cloud' },
+    
+    // Mobile
+    'react-native': { name: 'React Native', category: 'mobile' },
+    flutter: { name: 'Flutter', category: 'mobile' },
+    swift: { name: 'Swift', category: 'mobile' },
+    kotlin: { name: 'Kotlin', category: 'mobile' }
+};
+  
+module.exports = {
+    TOOLS,
+    DEPARTMENTS,
+    STACKS
+};