guild-agents 0.1.0 → 0.2.1

package/bin/guild.js

@@ -26,8 +26,13 @@ program
   .command('init')
   .description('Inicializar Guild v1 en el proyecto actual')
   .action(async () => {
-    const { runInit } = await import('../src/commands/init.js');
-    await runInit();
+    try {
+      const { runInit } = await import('../src/commands/init.js');
+      await runInit();
+    } catch (err) {
+      console.error(err.message);
+      process.exit(1);
+    }
   });
 
 // guild new-agent
@@ -36,8 +41,13 @@ program
   .description('Crear un nuevo agente')
   .argument('<name>', 'Nombre del agente (lowercase, guiones)')
   .action(async (name) => {
-    const { runNewAgent } = await import('../src/commands/new-agent.js');
-    await runNewAgent(name);
+    try {
+      const { runNewAgent } = await import('../src/commands/new-agent.js');
+      await runNewAgent(name);
+    } catch (err) {
+      console.error(err.message);
+      process.exit(1);
+    }
   });
 
 // guild status
@@ -45,8 +55,41 @@ program
   .command('status')
   .description('Ver estado del proyecto Guild')
   .action(async () => {
-    const { runStatus } = await import('../src/commands/status.js');
-    await runStatus();
+    try {
+      const { runStatus } = await import('../src/commands/status.js');
+      await runStatus();
+    } catch (err) {
+      console.error(err.message);
+      process.exit(1);
+    }
+  });
+
+// guild doctor
+program
+  .command('doctor')
+  .description('Verify Guild setup and report issues')
+  .action(async () => {
+    try {
+      const { runDoctor } = await import('../src/commands/doctor.js');
+      await runDoctor();
+    } catch (err) {
+      console.error(err.message);
+      process.exit(1);
+    }
+  });
+
+// guild list
+program
+  .command('list')
+  .description('List installed agents and skills')
+  .action(async () => {
+    try {
+      const { runList } = await import('../src/commands/list.js');
+      await runList();
+    } catch (err) {
+      console.error(err.message);
+      process.exit(1);
+    }
   });
 
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "guild-agents",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "A multi-agent framework for Claude Code — specialized AI teams for every project",
   "type": "module",
   "files": [
@@ -11,7 +11,7 @@
     "!src/utils/__tests__/"
   ],
   "bin": {
-    "guild": "./bin/guild.js"
+    "guild": "bin/guild.js"
   },
   "scripts": {
     "test": "vitest run",
@@ -51,7 +51,6 @@
     "@clack/prompts": "^0.9.0",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
-    "fs-extra": "^11.2.0",
     "picocolors": "^1.0.0"
   },
   "engines": {

package/src/commands/__tests__/doctor.test.js

@@ -0,0 +1,85 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { mkdirSync, rmSync, mkdtempSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+describe('runDoctor', () => {
+  let tempDir;
+  let originalCwd;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'guild-doctor-'));
+    originalCwd = process.cwd();
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('should pass all checks for a healthy project', async () => {
+    // Setup a complete Guild project
+    mkdirSync(join(tempDir, '.claude', 'agents'), { recursive: true });
+    mkdirSync(join(tempDir, '.claude', 'skills', 'build-feature'), { recursive: true });
+    writeFileSync(join(tempDir, '.claude', 'agents', 'advisor.md'), '---\nname: advisor\n---');
+    writeFileSync(join(tempDir, '.claude', 'skills', 'build-feature', 'SKILL.md'), '---\nname: build-feature\n---');
+    writeFileSync(join(tempDir, 'CLAUDE.md'), '# CLAUDE');
+    writeFileSync(join(tempDir, 'PROJECT.md'), '# PROJECT');
+    writeFileSync(join(tempDir, 'SESSION.md'), '# SESSION');
+
+    process.chdir(tempDir);
+    const { runDoctor } = await import('../doctor.js');
+    // Should not throw for healthy project
+    await expect(runDoctor()).resolves.toBeUndefined();
+  });
+
+  it('should throw when .claude directory is missing', async () => {
+    writeFileSync(join(tempDir, 'CLAUDE.md'), '# CLAUDE');
+    writeFileSync(join(tempDir, 'PROJECT.md'), '# PROJECT');
+    writeFileSync(join(tempDir, 'SESSION.md'), '# SESSION');
+
+    process.chdir(tempDir);
+    const { runDoctor } = await import('../doctor.js');
+    await expect(runDoctor()).rejects.toThrow('Guild setup has issues');
+  });
+
+  it('should throw when agents directory is empty', async () => {
+    mkdirSync(join(tempDir, '.claude', 'agents'), { recursive: true });
+    mkdirSync(join(tempDir, '.claude', 'skills', 'test-skill'), { recursive: true });
+    writeFileSync(join(tempDir, '.claude', 'skills', 'test-skill', 'SKILL.md'), '---\nname: test\n---');
+    writeFileSync(join(tempDir, 'CLAUDE.md'), '# CLAUDE');
+    writeFileSync(join(tempDir, 'PROJECT.md'), '# PROJECT');
+    writeFileSync(join(tempDir, 'SESSION.md'), '# SESSION');
+
+    process.chdir(tempDir);
+    const { runDoctor } = await import('../doctor.js');
+    await expect(runDoctor()).rejects.toThrow('Guild setup has issues');
+  });
+
+  it('should throw when CLAUDE.md is missing', async () => {
+    mkdirSync(join(tempDir, '.claude', 'agents'), { recursive: true });
+    mkdirSync(join(tempDir, '.claude', 'skills', 'test-skill'), { recursive: true });
+    writeFileSync(join(tempDir, '.claude', 'agents', 'advisor.md'), '---\nname: advisor\n---');
+    writeFileSync(join(tempDir, '.claude', 'skills', 'test-skill', 'SKILL.md'), '---\nname: test\n---');
+    writeFileSync(join(tempDir, 'PROJECT.md'), '# PROJECT');
+    writeFileSync(join(tempDir, 'SESSION.md'), '# SESSION');
+
+    process.chdir(tempDir);
+    const { runDoctor } = await import('../doctor.js');
+    await expect(runDoctor()).rejects.toThrow('Guild setup has issues');
+  });
+
+  it('should throw when PROJECT.md is missing', async () => {
+    mkdirSync(join(tempDir, '.claude', 'agents'), { recursive: true });
+    mkdirSync(join(tempDir, '.claude', 'skills', 'test-skill'), { recursive: true });
+    writeFileSync(join(tempDir, '.claude', 'agents', 'advisor.md'), '---\nname: advisor\n---');
+    writeFileSync(join(tempDir, '.claude', 'skills', 'test-skill', 'SKILL.md'), '---\nname: test\n---');
+    writeFileSync(join(tempDir, 'CLAUDE.md'), '# CLAUDE');
+    writeFileSync(join(tempDir, 'SESSION.md'), '# SESSION');
+
+    process.chdir(tempDir);
+    const { runDoctor } = await import('../doctor.js');
+    await expect(runDoctor()).rejects.toThrow('Guild setup has issues');
+  });
+});

package/src/commands/__tests__/list.test.js

@@ -0,0 +1,82 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { mkdirSync, rmSync, mkdtempSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+describe('runList', () => {
+  let tempDir;
+  let originalCwd;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'guild-list-'));
+    originalCwd = process.cwd();
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('should list agents and skills with descriptions', async () => {
+    mkdirSync(join(tempDir, '.claude', 'agents'), { recursive: true });
+    mkdirSync(join(tempDir, '.claude', 'skills', 'build-feature'), { recursive: true });
+    writeFileSync(
+      join(tempDir, '.claude', 'agents', 'advisor.md'),
+      '---\nname: advisor\ndescription: "Strategic advisor"\n---\n# Advisor'
+    );
+    writeFileSync(
+      join(tempDir, '.claude', 'skills', 'build-feature', 'SKILL.md'),
+      '---\nname: build-feature\ndescription: "Full pipeline"\n---\n# Build Feature'
+    );
+
+    process.chdir(tempDir);
+    const { runList } = await import('../list.js');
+    await expect(runList()).resolves.toBeUndefined();
+  });
+
+  it('should handle missing agents directory', async () => {
+    mkdirSync(join(tempDir, '.claude', 'skills', 'test'), { recursive: true });
+    writeFileSync(
+      join(tempDir, '.claude', 'skills', 'test', 'SKILL.md'),
+      '---\nname: test\n---'
+    );
+
+    process.chdir(tempDir);
+    const { runList } = await import('../list.js');
+    await expect(runList()).resolves.toBeUndefined();
+  });
+
+  it('should handle missing skills directory', async () => {
+    mkdirSync(join(tempDir, '.claude', 'agents'), { recursive: true });
+    writeFileSync(
+      join(tempDir, '.claude', 'agents', 'advisor.md'),
+      '---\nname: advisor\n---'
+    );
+
+    process.chdir(tempDir);
+    const { runList } = await import('../list.js');
+    await expect(runList()).resolves.toBeUndefined();
+  });
+
+  it('should handle empty directories', async () => {
+    mkdirSync(join(tempDir, '.claude', 'agents'), { recursive: true });
+    mkdirSync(join(tempDir, '.claude', 'skills'), { recursive: true });
+
+    process.chdir(tempDir);
+    const { runList } = await import('../list.js');
+    await expect(runList()).resolves.toBeUndefined();
+  });
+
+  it('should handle agents without frontmatter', async () => {
+    mkdirSync(join(tempDir, '.claude', 'agents'), { recursive: true });
+    writeFileSync(
+      join(tempDir, '.claude', 'agents', 'custom.md'),
+      '# Custom Agent\nNo frontmatter here'
+    );
+
+    process.chdir(tempDir);
+    const { runList } = await import('../list.js');
+    await expect(runList()).resolves.toBeUndefined();
+  });
+});

package/src/commands/__tests__/new-agent.test.js

@@ -0,0 +1,40 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { mkdirSync, rmSync, mkdtempSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+describe('runNewAgent', () => {
+  let tempDir;
+  let originalCwd;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'guild-test-'));
+    originalCwd = process.cwd();
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('should throw with invalid agent name', async () => {
+    process.chdir(tempDir);
+    const { runNewAgent } = await import('../new-agent.js');
+    await expect(runNewAgent('Invalid Name!')).rejects.toThrow('Nombre invalido');
+  });
+
+  it('should throw when .claude/agents/ does not exist', async () => {
+    process.chdir(tempDir);
+    const { runNewAgent } = await import('../new-agent.js');
+    await expect(runNewAgent('valid-name')).rejects.toThrow('Guild no esta instalado');
+  });
+
+  it('should throw when agent already exists', async () => {
+    process.chdir(tempDir);
+    mkdirSync(join(tempDir, '.claude', 'agents'), { recursive: true });
+    writeFileSync(join(tempDir, '.claude', 'agents', 'existing.md'), '# existing');
+    const { runNewAgent } = await import('../new-agent.js');
+    await expect(runNewAgent('existing')).rejects.toThrow('ya existe');
+  });
+});

package/src/commands/__tests__/status.test.js

@@ -0,0 +1,35 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { mkdirSync, writeFileSync, rmSync, mkdtempSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+describe('runStatus', () => {
+  let tempDir;
+  let originalCwd;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'guild-test-'));
+    originalCwd = process.cwd();
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('should throw when PROJECT.md does not exist', async () => {
+    process.chdir(tempDir);
+    const { runStatus } = await import('../status.js');
+    await expect(runStatus()).rejects.toThrow('Guild no esta instalado');
+  });
+
+  it('should not throw when PROJECT.md exists', async () => {
+    process.chdir(tempDir);
+    writeFileSync(join(tempDir, 'PROJECT.md'), '**Nombre:** TestProject\n**Stack:** Node.js');
+    mkdirSync(join(tempDir, '.claude', 'agents'), { recursive: true });
+    mkdirSync(join(tempDir, '.claude', 'skills'), { recursive: true });
+    const { runStatus } = await import('../status.js');
+    await expect(runStatus()).resolves.not.toThrow();
+  });
+});

package/src/commands/doctor.js

@@ -0,0 +1,99 @@
+/**
+ * doctor.js — Validates Guild setup and reports actionable fixes
+ */
+
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { existsSync, readdirSync } from 'fs';
+import { join } from 'path';
+
+export async function runDoctor() {
+  p.intro(chalk.bold.cyan('Guild — Doctor'));
+
+  const checks = [];
+  let healthy = true;
+
+  // Check .claude/ directory
+  if (existsSync('.claude')) {
+    checks.push({ name: '.claude/ directory', pass: true });
+  } else {
+    checks.push({ name: '.claude/ directory', pass: false, fix: 'Run: guild init' });
+    healthy = false;
+  }
+
+  // Check agents
+  const agentsDir = join('.claude', 'agents');
+  if (existsSync(agentsDir)) {
+    const agents = readdirSync(agentsDir).filter(f => f.endsWith('.md'));
+    if (agents.length > 0) {
+      checks.push({ name: `Agents (${agents.length} found)`, pass: true });
+    } else {
+      checks.push({ name: 'Agents', pass: false, fix: 'Run: guild init (no agent .md files found in .claude/agents/)' });
+      healthy = false;
+    }
+  } else {
+    checks.push({ name: 'Agents directory', pass: false, fix: 'Run: guild init (missing .claude/agents/)' });
+    healthy = false;
+  }
+
+  // Check skills
+  const skillsDir = join('.claude', 'skills');
+  if (existsSync(skillsDir)) {
+    const skills = readdirSync(skillsDir, { withFileTypes: true })
+      .filter(d => d.isDirectory())
+      .filter(d => existsSync(join(skillsDir, d.name, 'SKILL.md')));
+    if (skills.length > 0) {
+      checks.push({ name: `Skills (${skills.length} found)`, pass: true });
+    } else {
+      checks.push({ name: 'Skills', pass: false, fix: 'Run: guild init (no SKILL.md files found in .claude/skills/)' });
+      healthy = false;
+    }
+  } else {
+    checks.push({ name: 'Skills directory', pass: false, fix: 'Run: guild init (missing .claude/skills/)' });
+    healthy = false;
+  }
+
+  // Check CLAUDE.md
+  if (existsSync('CLAUDE.md')) {
+    checks.push({ name: 'CLAUDE.md', pass: true });
+  } else {
+    checks.push({ name: 'CLAUDE.md', pass: false, fix: 'Run: guild init (creates CLAUDE.md with project instructions)' });
+    healthy = false;
+  }
+
+  // Check PROJECT.md
+  if (existsSync('PROJECT.md')) {
+    checks.push({ name: 'PROJECT.md', pass: true });
+  } else {
+    checks.push({ name: 'PROJECT.md', pass: false, fix: 'Run: guild init (creates PROJECT.md with project identity)' });
+    healthy = false;
+  }
+
+  // Check SESSION.md
+  if (existsSync('SESSION.md')) {
+    checks.push({ name: 'SESSION.md', pass: true });
+  } else {
+    checks.push({ name: 'SESSION.md', pass: false, fix: 'Run: guild init (creates SESSION.md for session tracking)' });
+    healthy = false;
+  }
+
+  // Display results
+  for (const check of checks) {
+    if (check.pass) {
+      p.log.success(`${chalk.green('✓')} ${check.name}`);
+    } else {
+      p.log.error(`${chalk.red('✗')} ${check.name}`);
+      p.log.info(chalk.gray(`  Fix: ${check.fix}`));
+    }
+  }
+
+  const passed = checks.filter(c => c.pass).length;
+  const total = checks.length;
+
+  if (healthy) {
+    p.outro(chalk.green(`All checks passed (${passed}/${total})`));
+  } else {
+    p.outro(chalk.red(`${total - passed} issue(s) found (${passed}/${total} passed)`));
+    throw new Error('Guild setup has issues. Run the suggested fixes above.');
+  }
+}

package/src/commands/init.js

@@ -28,7 +28,7 @@ export async function runInit() {
 
     if (p.isCancel(overwrite) || !overwrite) {
       p.cancel('Cancelado.');
-      process.exit(0);
+      return;
     }
   }
 
@@ -40,7 +40,7 @@ export async function runInit() {
       if (!val) return 'El nombre es requerido';
     },
   });
-  if (p.isCancel(name)) { p.cancel('Cancelado.'); process.exit(0); }
+  if (p.isCancel(name)) { p.cancel('Cancelado.'); return; }
 
   // ─── Tipo ───────────────────────────────────────────────────────────────────
   const type = await p.select({
@@ -53,7 +53,7 @@ export async function runInit() {
       { value: 'fullstack', label: 'Otro / Fullstack' },
     ],
   });
-  if (p.isCancel(type)) { p.cancel('Cancelado.'); process.exit(0); }
+  if (p.isCancel(type)) { p.cancel('Cancelado.'); return; }
 
   // ─── Stack ──────────────────────────────────────────────────────────────────
   const stack = await p.text({
@@ -63,7 +63,7 @@ export async function runInit() {
       if (!val) return 'El stack es requerido';
     },
   });
-  if (p.isCancel(stack)) { p.cancel('Cancelado.'); process.exit(0); }
+  if (p.isCancel(stack)) { p.cancel('Cancelado.'); return; }
 
   // ─── GitHub ─────────────────────────────────────────────────────────────────
   let github = null;
@@ -118,8 +118,7 @@ export async function runInit() {
     spinner.stop('Estructura creada.');
   } catch (error) {
     spinner.stop('Error durante la inicializacion.');
-    p.log.error(error.message);
-    process.exit(1);
+    throw error;
   }
 
   // ─── Resumen ────────────────────────────────────────────────────────────────

package/src/commands/list.js

@@ -0,0 +1,82 @@
+/**
+ * list.js — Lists installed agents and skills with descriptions
+ */
+
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { existsSync, readdirSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Parses YAML frontmatter from a markdown file content.
+ * Returns an object with key-value pairs from the frontmatter.
+ */
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return {};
+  const fm = {};
+  for (const line of match[1].split('\n')) {
+    const colonIndex = line.indexOf(':');
+    if (colonIndex === -1) continue;
+    const key = line.slice(0, colonIndex).trim();
+    const value = line.slice(colonIndex + 1).trim().replace(/^["']|["']$/g, '');
+    if (key && value) fm[key] = value;
+  }
+  return fm;
+}
+
+export async function runList() {
+  p.intro(chalk.bold.cyan('Guild — Agents & Skills'));
+
+  // List agents
+  const agentsDir = join('.claude', 'agents');
+  p.log.step('Agents');
+
+  if (existsSync(agentsDir)) {
+    const agentFiles = readdirSync(agentsDir).filter(f => f.endsWith('.md')).sort();
+    if (agentFiles.length > 0) {
+      for (const file of agentFiles) {
+        const content = readFileSync(join(agentsDir, file), 'utf8');
+        const fm = parseFrontmatter(content);
+        const name = fm.name || file.replace('.md', '');
+        const desc = fm.description || chalk.gray('(no description)');
+        p.log.info(`  ${chalk.bold(name)} — ${desc}`);
+      }
+    } else {
+      p.log.info(chalk.gray('  No agents found'));
+    }
+  } else {
+    p.log.info(chalk.gray('  No agents directory (.claude/agents/)'));
+  }
+
+  // List skills
+  const skillsDir = join('.claude', 'skills');
+  p.log.step('Skills');
+
+  if (existsSync(skillsDir)) {
+    const skillDirs = readdirSync(skillsDir, { withFileTypes: true })
+      .filter(d => d.isDirectory())
+      .map(d => d.name)
+      .sort();
+    if (skillDirs.length > 0) {
+      for (const dir of skillDirs) {
+        const skillFile = join(skillsDir, dir, 'SKILL.md');
+        if (existsSync(skillFile)) {
+          const content = readFileSync(skillFile, 'utf8');
+          const fm = parseFrontmatter(content);
+          const name = fm.name || dir;
+          const desc = fm.description || chalk.gray('(no description)');
+          p.log.info(`  ${chalk.bold(name)} — ${desc}`);
+        } else {
+          p.log.info(`  ${chalk.bold(dir)} — ${chalk.gray('(missing SKILL.md)')}`);
+        }
+      }
+    } else {
+      p.log.info(chalk.gray('  No skills found'));
+    }
+  } else {
+    p.log.info(chalk.gray('  No skills directory (.claude/skills/)'));
+  }
+
+  p.outro('');
+}

package/src/commands/new-agent.js

@@ -21,22 +21,18 @@ export async function runNewAgent(agentName) {
 
   // Validar nombre
   if (!isValidAgentName(agentName)) {
-    p.log.error(`Nombre invalido: "${agentName}". Solo lowercase, numeros y guiones.`);
-    p.log.info('Ejemplo: guild new-agent security-auditor');
-    process.exit(1);
+    throw new Error(`Nombre invalido: "${agentName}". Solo lowercase, numeros y guiones. Ejemplo: guild new-agent security-auditor`);
   }
 
   // Verificar Guild instalado
   if (!existsSync(AGENTS_DIR)) {
-    p.log.error('Guild no esta instalado. Ejecuta: guild init');
-    process.exit(1);
+    throw new Error('Guild no esta instalado. Ejecuta: guild init');
   }
 
   // Verificar que el agente NO existe
   const agentPath = join(AGENTS_DIR, `${agentName}.md`);
   if (existsSync(agentPath)) {
-    p.log.error(`El agente "${agentName}" ya existe.`);
-    process.exit(1);
+    throw new Error(`El agente "${agentName}" ya existe.`);
   }
 
   // Pedir descripcion
@@ -45,7 +41,7 @@ export async function runNewAgent(agentName) {
     placeholder: 'ej: Evalua oportunidades de trading basado en analisis tecnico',
     validate: (val) => !val ? 'La descripcion es requerida' : undefined,
   });
-  if (p.isCancel(description)) { p.cancel('Cancelado.'); process.exit(0); }
+  if (p.isCancel(description)) { p.cancel('Cancelado.'); return; }
 
   // Crear agente
   const spinner = p.spinner();
@@ -87,8 +83,7 @@ Eres ${agentName} de [PROYECTO].
     p.outro(chalk.bold.cyan(`Agente ${agentName} listo.`));
   } catch (error) {
     spinner.stop('Error al crear agente.');
-    p.log.error(error.message);
-    process.exit(1);
+    throw error;
   }
 }
 

package/src/commands/status.js

@@ -9,8 +9,7 @@ import { join } from 'path';
 
 export async function runStatus() {
   if (!existsSync('PROJECT.md')) {
-    p.log.error('Guild no esta instalado. Ejecuta: guild init');
-    process.exit(1);
+    throw new Error('Guild no esta instalado. Ejecuta: guild init');
   }
 
   const projectMd = readFileSync('PROJECT.md', 'utf8');

package/src/templates/agents/advisor.md

@@ -1,6 +1,8 @@
 ---
 name: advisor
 description: "Evalua ideas y da direccion estrategica antes de comprometer trabajo"
+tools: Read, Glob, Grep
+permissionMode: plan
 ---
 
 # Advisor

package/src/templates/agents/bugfix.md

@@ -1,6 +1,8 @@
 ---
 name: bugfix
 description: "Diagnostico y resolucion de bugs"
+tools: Read, Write, Edit, Bash, Glob, Grep
+permissionMode: bypassPermissions
 ---
 
 # Bugfix

package/src/templates/agents/code-reviewer.md

@@ -1,6 +1,8 @@
 ---
 name: code-reviewer
 description: "Revisa calidad, patterns, deuda tecnica"
+tools: Read, Glob, Grep
+permissionMode: plan
 ---
 
 # Code Reviewer

package/src/templates/agents/db-migration.md

@@ -1,6 +1,8 @@
 ---
 name: db-migration
 description: "Cambios de schema, migraciones seguras"
+tools: Read, Write, Edit, Bash, Glob, Grep
+permissionMode: bypassPermissions
 ---
 
 # DB Migration

package/src/templates/agents/developer.md

@@ -1,6 +1,8 @@
 ---
 name: developer
 description: "Implementa features siguiendo las convenciones del proyecto"
+tools: Read, Write, Edit, Bash, Glob, Grep
+permissionMode: bypassPermissions
 ---
 
 # Developer