@tacuchi/agent-factory 0.1.1 → 0.2.0

package/bin/agent-factory.js

@@ -39,6 +39,10 @@ program
   .option('-o, --output <path>', 'Output directory (default: current dir)')
   .option('-t, --target <target>', 'Target: claude, codex, all', 'all')
   .option('--tools <tools>', 'Comma-separated tools: Read,Write,Edit,Bash')
+  .option('--specialists <list>', 'CSV list of specialist agent names (for coordinator role)')
+  .option('--repo-count <n>', 'Number of repos in workspace (for coordinator role)', parseInt)
+  .option('--description <text>', 'Short description for the agent (for custom role)')
+  .option('--instructions <text>', 'Agent body: inline text or path to .md file (for custom role)')
   .option('-y, --yes', 'Skip confirmations')
   .action(async (options) => {
     const { runCreate } = require('../src/commands/create');

package/package.json

@@ -1,6 +1,6 @@
 {
 "name": "@tacuchi/agent-factory",
-"version": "0.1.1",
+"version": "0.2.0",
   "description": "CLI to create AI agents for Claude Code, Codex, Gemini CLI and more",
   "bin": {
     "agent-factory": "bin/agent-factory.js"

package/src/commands/create.js

@@ -10,37 +10,48 @@ async function runCreate(options = {}) {
   const isInteractive = !options.name;
   const config = isInteractive ? await askCreateOptions() : normalizeFlags(options);
 
-  const { name, role, model, scope, output, target, tools } = config;
+  const { name, role, model, scope, output, target, tools, specialists, repoCount, description, instructions } = config;
 
   const spin = spinner('Generating agent...').start();
 
-  let stackResult = { primaryTech: 'Generic', framework: '', verifyCommands: '', stackParts: [], stackCsv: 'Generic' };
-  if (scope) {
-    stackResult = await detect(scope);
-  }
+  let body;
 
-  const templateData = {
-    name,
-    primary_tech: stackResult.primaryTech,
-    framework: stackResult.framework,
-    scope: scope || '.',
-    stack_list: stackResult.stackParts.length > 0
-      ? stackResult.stackParts.map((p) => `- ${p}`).join('\n')
-      : `- ${stackResult.primaryTech}`,
-    verify_cmds: stackResult.verifyCommands || 'N/A',
-    stack_csv: stackResult.stackCsv,
-  };
+  if (role === 'custom') {
+    body = await resolveCustomBody(instructions, name, description);
+    spin.succeed('Custom agent generated');
+  } else {
+    let stackResult = { primaryTech: 'Generic', framework: '', verifyCommands: '', stackParts: [], stackCsv: 'Generic' };
+    if (scope) {
+      stackResult = await detect(scope);
+    }
 
-  const templateFile = `${role}.md.tmpl`;
-  let body;
-  try {
-    body = await renderFile(templateFile, templateData);
-  } catch {
-    spin.fail(`Template not found: ${templateFile}`);
-    process.exit(1);
-  }
+    const templateData = {
+      name,
+      primary_tech: stackResult.primaryTech,
+      framework: stackResult.framework,
+      scope: scope || '.',
+      stack_list: stackResult.stackParts.length > 0
+        ? stackResult.stackParts.map((p) => `- ${p}`).join('\n')
+        : `- ${stackResult.primaryTech}`,
+      verify_cmds: stackResult.verifyCommands || 'N/A',
+      stack_csv: stackResult.stackCsv,
+      specialist_list: formatSpecialistList(specialists),
+      N: repoCount ? String(repoCount) : '',
+      repos_word: repoCount === 1 ? 'repositorio' : 'repositorios',
+      skills_section: '',
+      mcp_section: '',
+    };
 
-  spin.succeed('Agent generated');
+    const templateFile = `${role}.md.tmpl`;
+    try {
+      body = await renderFile(templateFile, templateData);
+    } catch {
+      spin.fail(`Template not found: ${templateFile}`);
+      process.exit(1);
+    }
+
+    spin.succeed('Agent generated');
+  }
 
   const outputDir = output || process.cwd();
   const targetDirs = [];
@@ -64,6 +75,7 @@ async function runCreate(options = {}) {
     body,
     outputDir,
     target,
+    description: description || undefined,
   });
 
   const validator = new AgentValidator();
@@ -72,14 +84,18 @@ async function runCreate(options = {}) {
     const content = await fs.readFile(results.claude, 'utf8');
     const validation = validator.validate(content, `${name}.md`);
     if (validation.valid) {
-      log.success(`Claude: ${results.claude} (score: ${validation.score}/100)`);
+      log.success(`Claude:  ${results.claude} (score: ${validation.score}/100)`);
     } else {
-      log.warn(`Claude: ${results.claude} (score: ${validation.score}/100, ${validation.errorCount} errors)`);
+      log.warn(`Claude:  ${results.claude} (score: ${validation.score}/100, ${validation.errorCount} errors)`);
     }
   }
 
   if (results.codex) {
-    log.success(`Codex:  ${results.codex}`);
+    log.success(`Codex:   ${results.codex}`);
+  }
+
+  if (results.skills) {
+    log.success(`Skills:  ${results.skills}`);
   }
 }
 
@@ -93,7 +109,33 @@ function normalizeFlags(options) {
     target: options.target || 'all',
     tools: options.tools || '',
     yes: options.yes || false,
+    specialists: options.specialists || '',
+    repoCount: options.repoCount || 0,
+    description: options.description || '',
+    instructions: options.instructions || '',
   };
 }
 
+function formatSpecialistList(csv) {
+  if (!csv) return '';
+  const names = csv.split(',').map((n) => n.trim()).filter(Boolean);
+  if (names.length === 0) return '';
+  if (names.length === 1) return `\`${names[0]}\``;
+  const last = names.pop();
+  return names.map((n) => `\`${n}\``).join(', ') + ` y \`${last}\``;
+}
+
+async function resolveCustomBody(instructions, name, description) {
+  if (!instructions) {
+    return `# ${name}\n\n${description || 'Custom agent.'}\n`;
+  }
+
+  const fs = require('fs-extra');
+  if (instructions.endsWith('.md') && await fs.pathExists(instructions)) {
+    return await fs.readFile(instructions, 'utf8');
+  }
+
+  return `# ${name}\n\n${instructions}\n`;
+}
+
 module.exports = { runCreate };

package/src/commands/list.js

@@ -32,6 +32,24 @@ async function runList(dirPath, options = {}) {
     }
   }
 
+  const skillsDir = path.join(abs, '.agents', 'skills');
+  if (await fs.pathExists(skillsDir)) {
+    const skillDirs = (await fs.readdir(skillsDir, { withFileTypes: true })).filter((d) => d.isDirectory());
+    for (const dir of skillDirs) {
+      const skillFile = path.join(skillsDir, dir.name, 'SKILL.md');
+      if (await fs.pathExists(skillFile)) {
+        const file = `${dir.name}.md`;
+        const existing = agents.find((a) => a.file === file);
+        if (existing) {
+          existing.skillsToo = true;
+          continue;
+        }
+        const content = await fs.readFile(skillFile, 'utf8');
+        agents.push({ file, source: '.agents/skills', content, format: 'skills' });
+      }
+    }
+  }
+
   if (agents.length === 0) {
     if (options.json) {
       console.log(JSON.stringify([]));
@@ -51,7 +69,7 @@ async function runList(dirPath, options = {}) {
       return {
         name: fm?.name || agent.file.replace('.md', ''),
         model: fm?.model || null,
-        source: agent.codexToo ? 'both' : agent.source,
+        source: resolveSource(agent),
         score: validation.score,
         valid: validation.valid,
       };
@@ -72,7 +90,7 @@ async function runList(dirPath, options = {}) {
     const fm = extractFrontmatter(agent.content);
     const name = fm?.name || agent.file.replace('.md', '');
     const model = fm?.model || '—';
-    const source = agent.codexToo ? 'both' : agent.source;
+    const source = resolveSource(agent);
 
     const validation = validator.validate(agent.content, agent.file);
     const scoreStr = `${validation.score}/100`;
@@ -100,6 +118,16 @@ async function runList(dirPath, options = {}) {
   console.log('');
 }
 
+function resolveSource(agent) {
+  const parts = [];
+  if (agent.source === '.claude/agents' || agent.codexToo) parts.push('claude');
+  if (agent.source === '.agents' || agent.codexToo) parts.push('codex');
+  if (agent.skillsToo || agent.source === '.agents/skills') parts.push('skills');
+  if (parts.length === 3) return 'all';
+  if (parts.length === 0) return agent.source;
+  return parts.join('+');
+}
+
 function padRow(name, model, source, score) {
   return `  ${name.padEnd(30)} ${model.padEnd(10)} ${source.padEnd(18)} ${score}`;
 }

package/src/core/agent-writer.js

@@ -4,9 +4,10 @@ const yaml = require('js-yaml');
 
 const TOOLS_BY_ROLE = {
   specialist: 'Read, Write, Edit, Bash',
-  coordinator: 'Read, Bash, Task',
+  coordinator: 'Read, Glob, Grep, Task, Bash',
   reviewer: 'Read, Grep, Glob, Bash',
   architect: 'Read, Grep, Glob, Bash',
+  custom: 'Read, Bash',
 };
 
 function buildClaudeFormat(name, description, model, tools, body) {
@@ -32,9 +33,13 @@ function buildDescription(role, primaryTech, framework) {
   return descriptions[role] || `Agent for ${tech}`;
 }
 
-async function writeAgent({ name, role, model, tools, body, outputDir, target }) {
-  const results = { claude: null, codex: null };
-  const description = body.split('\n').find((l) => l.trim() && !l.startsWith('#'))?.trim() || name;
+function buildSkillsFormat(name, description, body) {
+  return `---\nname: ${name}\ndescription: "${description}"\n---\n\n${body}\n`;
+}
+
+async function writeAgent({ name, role, model, tools, body, outputDir, target, description: customDesc }) {
+  const results = { claude: null, codex: null, skills: null };
+  const description = customDesc || body.split('\n').find((l) => l.trim() && !l.startsWith('#'))?.trim() || name;
 
   const resolvedTools = tools || TOOLS_BY_ROLE[role] || 'Read, Write, Edit, Bash';
 
@@ -56,7 +61,16 @@ async function writeAgent({ name, role, model, tools, body, outputDir, target })
     results.codex = codexPath;
   }
 
+  if (target === 'codex' || target === 'all') {
+    const skillsDir = path.join(outputDir, '.agents', 'skills', name);
+    await fs.ensureDir(skillsDir);
+    const skillsContent = buildSkillsFormat(name, description, body);
+    const skillsPath = path.join(skillsDir, 'SKILL.md');
+    await fs.writeFile(skillsPath, skillsContent, 'utf8');
+    results.skills = skillsPath;
+  }
+
   return results;
 }
 
-module.exports = { writeAgent, buildClaudeFormat, buildCodexFormat, buildDescription, TOOLS_BY_ROLE };
+module.exports = { writeAgent, buildClaudeFormat, buildCodexFormat, buildSkillsFormat, buildDescription, TOOLS_BY_ROLE };

package/src/utils/prompts.js

@@ -6,6 +6,7 @@ const ROLES = [
   { name: 'coordinator — Orchestrates across repos', value: 'coordinator' },
   { name: 'reviewer — Code review and quality analysis', value: 'reviewer' },
   { name: 'architect — System design and technical decisions', value: 'architect' },
+  { name: 'custom — Free-form agent with custom instructions', value: 'custom' },
 ];
 
 const MODELS = [
@@ -21,7 +22,7 @@ const TARGETS = [
 ];
 
 async function askCreateOptions() {
-  const answers = await inquirer.prompt([
+  const baseQuestions = [
     {
       type: 'input',
       name: 'name',
@@ -40,13 +41,39 @@ async function askCreateOptions() {
       message: 'Model:',
       choices: MODELS,
     },
-    {
-      type: 'input',
-      name: 'scope',
-      message: 'Repository path (for stack detection, optional):',
-      default: '',
-      filter: (v) => (v ? path.resolve(v) : ''),
-    },
+  ];
+
+  const answers = await inquirer.prompt(baseQuestions);
+
+  if (answers.role === 'custom') {
+    const customAnswers = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'description',
+        message: 'Short description for the agent:',
+        validate: (v) => v.length >= 5 || 'Description must be at least 5 characters',
+      },
+      {
+        type: 'editor',
+        name: 'instructions',
+        message: 'Agent instructions (opens editor):',
+      },
+    ]);
+    Object.assign(answers, customAnswers);
+  } else {
+    const scopeAnswers = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'scope',
+        message: 'Repository path (for stack detection, optional):',
+        default: '',
+        filter: (v) => (v ? path.resolve(v) : ''),
+      },
+    ]);
+    Object.assign(answers, scopeAnswers);
+  }
+
+  const outputAnswers = await inquirer.prompt([
     {
       type: 'list',
       name: 'target',
@@ -62,7 +89,7 @@ async function askCreateOptions() {
     },
   ]);
 
-  return answers;
+  return { ...answers, ...outputAnswers };
 }
 
 async function confirmGeneration(agentName, files) {

package/templates/roles/coordinator.md.tmpl

@@ -1,17 +1,25 @@
 # {{name}}
 
-Coordinador del workspace. Proporciona vision global, orienta sobre que especialista usar y consolida resultados.
+Guia multi-repo del workspace. Proporciona vision global de {{N}} {{repos_word}} externos, orienta sobre que especialista usar y consolida resultados.
+
+## Agentes especialistas disponibles
+
+{{specialist_list}}
+
+Cada especialista opera exclusivamente dentro de su repo asignado. Para ejecutar cambios en un repo especifico, invoca al especialista correspondiente usando `/agents` o `Task`.
 
 ## Reglas
 
-- **Vision global**: este agente conoce la arquitectura completa del workspace.
+- **Vision global**: este agente conoce la arquitectura completa del workspace y la relacion entre los repos.
 - Puede **leer y buscar** en cualquier repo del workspace para analisis cross-repo.
-- **No implementar cambios directamente** en repos externos. Indicar al usuario que invoque al especialista correspondiente.
+- **No implementar cambios directamente** en repos externos. Indicar al usuario que invoque al especialista correspondiente, o usar la herramienta Task para delegarle la subtarea.
+- Cuando haya subtareas independientes en repos distintos, sugerir al usuario ejecutarlas en paralelo.
 - Siempre producir un **resumen** con:
   - Plan de accion por repo
   - Especialista recomendado para cada subtarea
   - Comandos de verificacion pendientes
-- Consolidar resultados y documentacion en `./docs/`.
+- Consolidar resultados y documentacion en `./docs/<tema>/`.
+- Seguir el protocolo cross-repo definido en AGENTS.md (o CLAUDE.md): planificar primero, cambios minimos, reportar archivos tocados.
 
 ## Flujo de trabajo
 
@@ -20,3 +28,9 @@ Coordinador del workspace. Proporciona vision global, orienta sobre que especial
 3. Si es solo un repo: orientar al usuario hacia el especialista correspondiente.
 4. Si es cross-repo: planificar la secuencia, indicar el orden de invocacion de especialistas.
 5. Consolidar documentacion y reportar al usuario.
+
+## Agentes globales (gestionados por el usuario)
+
+Si el usuario ha creado agentes globales/personales en el workspace (por ejemplo, agentes transversales de arquitectura, estilo o revision de codigo), puedes invocarlos para obtener analisis cross-repo. Estos agentes son gestionados directamente por el usuario y pueden no estar presentes en todos los workspaces.
+{{skills_section}}
+{{mcp_section}}