@tacuchi/agent-factory 0.1.0

package/src/core/agent-validator.js

@@ -0,0 +1,162 @@
+const yaml = require('js-yaml');
+
+const VALID_MODELS = ['opus', 'sonnet', 'haiku', 'inherit'];
+const VALID_TOOLS = ['Read', 'Write', 'Edit', 'Bash', 'Grep', 'Glob', 'WebSearch', 'Task'];
+
+const SECRET_PATTERNS = [
+  /AIzaSy[\w-]{30,}/,
+  /sk-[A-Za-z0-9]{20,}/,
+  /ghp_[A-Za-z0-9]{36}/,
+  /gho_[A-Za-z0-9]{36}/,
+  /-----BEGIN (RSA |EC )?PRIVATE KEY-----/,
+  /api[_-]?key\s*[:=]\s*['"][^'"]{10,}['"]/i,
+  /token\s*[:=]\s*['"][^'"]{10,}['"]/i,
+  /password\s*[:=]\s*['"][^'"]{3,}['"]/i,
+];
+
+const ABSOLUTE_PATH_PATTERN = /(?:\/(?:Users|home|root|etc|var)\/|[A-Z]:\\)/;
+
+class AgentValidator {
+  constructor() {
+    this.errors = [];
+    this.warnings = [];
+    this.info = [];
+  }
+
+  addError(code, message, metadata = {}) {
+    this.errors.push({ level: 'error', code, message, metadata });
+  }
+
+  addWarning(code, message, metadata = {}) {
+    this.warnings.push({ level: 'warning', code, message, metadata });
+  }
+
+  addInfo(code, message, metadata = {}) {
+    this.info.push({ level: 'info', code, message, metadata });
+  }
+
+  isValid() {
+    return this.errors.length === 0;
+  }
+
+  getScore() {
+    const errorPenalty = this.errors.length * 25;
+    const warningPenalty = this.warnings.length * 5;
+    return Math.max(0, 100 - errorPenalty - warningPenalty);
+  }
+
+  getResults() {
+    return {
+      valid: this.isValid(),
+      score: this.getScore(),
+      errorCount: this.errors.length,
+      warningCount: this.warnings.length,
+      infoCount: this.info.length,
+      errors: this.errors,
+      warnings: this.warnings,
+      info: this.info,
+    };
+  }
+
+  reset() {
+    this.errors = [];
+    this.warnings = [];
+    this.info = [];
+  }
+
+  validate(content, filename = '') {
+    this.reset();
+
+    if (!content || typeof content !== 'string') {
+      this.addError('VAL_E001', 'Content is empty or not a string');
+      return this.getResults();
+    }
+
+    const frontmatter = this.extractFrontmatter(content);
+
+    if (frontmatter) {
+      this.validateFrontmatter(frontmatter);
+    } else {
+      this.addInfo('VAL_I001', 'No YAML frontmatter found (Codex/plain format)');
+    }
+
+    this.checkSecrets(content);
+    this.checkAbsolutePaths(content);
+
+    if (filename && !this.isKebabCase(filename.replace(/\.md$/, ''))) {
+      this.addWarning('VAL_W010', `Filename "${filename}" should use kebab-case`);
+    }
+
+    const bodyLength = this.extractBody(content).trim().length;
+    if (bodyLength < 50) {
+      this.addWarning('VAL_W011', `Agent body is very short (${bodyLength} chars)`);
+    }
+
+    return this.getResults();
+  }
+
+  extractFrontmatter(content) {
+    const match = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!match) return null;
+
+    try {
+      return yaml.load(match[1]);
+    } catch (err) {
+      this.addError('VAL_E002', `Invalid YAML frontmatter: ${err.message}`);
+      return null;
+    }
+  }
+
+  extractBody(content) {
+    const match = content.match(/^---\n[\s\S]*?\n---\n?([\s\S]*)$/);
+    return match ? match[1] : content;
+  }
+
+  validateFrontmatter(fm) {
+    if (!fm.name) {
+      this.addError('VAL_E003', 'Missing required field: name');
+    } else if (!this.isKebabCase(fm.name)) {
+      this.addWarning('VAL_W001', `Agent name "${fm.name}" should use kebab-case`);
+    }
+
+    if (!fm.description) {
+      this.addError('VAL_E004', 'Missing required field: description');
+    } else if (fm.description.length < 10) {
+      this.addWarning('VAL_W002', 'Description is too short');
+    }
+
+    if (!fm.model) {
+      this.addWarning('VAL_W003', 'Missing field: model (will use default)');
+    } else if (!VALID_MODELS.includes(fm.model)) {
+      this.addWarning('VAL_W004', `Model "${fm.model}" is not a standard value: ${VALID_MODELS.join(', ')}`);
+    }
+
+    if (fm.tools) {
+      const tools = typeof fm.tools === 'string' ? fm.tools.split(',').map((t) => t.trim()) : fm.tools;
+      const invalid = tools.filter((t) => !VALID_TOOLS.includes(t));
+      if (invalid.length > 0) {
+        this.addWarning('VAL_W005', `Unknown tools: ${invalid.join(', ')}`);
+      }
+    }
+  }
+
+  checkSecrets(content) {
+    for (const pattern of SECRET_PATTERNS) {
+      if (pattern.test(content)) {
+        this.addError('VAL_E010', `Potential secret detected matching pattern: ${pattern.source.slice(0, 30)}...`);
+      }
+    }
+  }
+
+  checkAbsolutePaths(content) {
+    if (ABSOLUTE_PATH_PATTERN.test(content)) {
+      this.addWarning('VAL_W020', 'Content contains absolute paths; prefer relative paths or $CLAUDE_PROJECT_DIR');
+    }
+  }
+
+  isKebabCase(str) {
+    return /^[a-z0-9]+(-[a-z0-9]+)*$/.test(str);
+  }
+}
+
+module.exports = { AgentValidator, VALID_MODELS, VALID_TOOLS };

package/src/core/agent-writer.js

@@ -0,0 +1,62 @@
+const fs = require('fs-extra');
+const path = require('path');
+const yaml = require('js-yaml');
+
+const TOOLS_BY_ROLE = {
+  specialist: 'Read, Write, Edit, Bash',
+  coordinator: 'Read, Bash, Task',
+  reviewer: 'Read, Grep, Glob, Bash',
+  architect: 'Read, Grep, Glob, Bash',
+};
+
+function buildClaudeFormat(name, description, model, tools, body) {
+  const frontmatter = yaml.dump(
+    { name, description, tools, model },
+    { lineWidth: -1, quotingType: '"', forceQuotes: false }
+  ).trim();
+  return `---\n${frontmatter}\n---\n\n${body}\n`;
+}
+
+function buildCodexFormat(body) {
+  return `${body}\n`;
+}
+
+function buildDescription(role, primaryTech, framework) {
+  const tech = framework ? `${framework} (${primaryTech})` : primaryTech;
+  const descriptions = {
+    specialist: `Specialist agent for ${tech} development`,
+    coordinator: 'Workspace coordinator with cross-repo visibility',
+    reviewer: `Code reviewer for ${tech} projects`,
+    architect: `Software architect for ${tech} systems`,
+  };
+  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;
+
+  const resolvedTools = tools || TOOLS_BY_ROLE[role] || 'Read, Write, Edit, Bash';
+
+  if (target === 'claude' || target === 'all') {
+    const claudeDir = path.join(outputDir, '.claude', 'agents');
+    await fs.ensureDir(claudeDir);
+    const claudeContent = buildClaudeFormat(name, description, model, resolvedTools, body);
+    const claudePath = path.join(claudeDir, `${name}.md`);
+    await fs.writeFile(claudePath, claudeContent, 'utf8');
+    results.claude = claudePath;
+  }
+
+  if (target === 'codex' || target === 'all') {
+    const codexDir = path.join(outputDir, '.agents');
+    await fs.ensureDir(codexDir);
+    const codexContent = buildCodexFormat(body);
+    const codexPath = path.join(codexDir, `${name}.md`);
+    await fs.writeFile(codexPath, codexContent, 'utf8');
+    results.codex = codexPath;
+  }
+
+  return results;
+}
+
+module.exports = { writeAgent, buildClaudeFormat, buildCodexFormat, buildDescription, TOOLS_BY_ROLE };

package/src/core/stack-detector.js

@@ -0,0 +1,319 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+function sanitize(value, maxLen = 100) {
+  if (!value) return '';
+  return value
+    .replace(/[\x00-\x09\x0B-\x1F]/g, '')
+    .replace(/`/g, '')
+    .replace(/\$\([^)]*\)/g, '')
+    .replace(/\$\{[^}]*\}/g, '')
+    .replace(/<!--[^>]*-->/g, '')
+    .replace(/\{\{[^}]*\}\}/g, '')
+    .replace(/[<>]/g, '')
+    .slice(0, maxLen)
+    .trim();
+}
+
+async function findFiles(dir, extensions, maxDepth = 2) {
+  const results = [];
+
+  async function walk(current, depth) {
+    if (depth > maxDepth) return;
+    try {
+      const entries = await fs.readdir(current, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.name.startsWith('.') || entry.name === 'node_modules' || entry.name === 'vendor') continue;
+        const full = path.join(current, entry.name);
+        if (entry.isDirectory()) {
+          await walk(full, depth + 1);
+        } else if (extensions.some((ext) => entry.name.endsWith(ext))) {
+          results.push(full);
+        }
+      }
+    } catch {
+      // directorio inaccesible
+    }
+  }
+
+  await walk(dir, 0);
+  return results;
+}
+
+function readJsonSafe(filePath) {
+  try {
+    return fs.readJsonSync(filePath);
+  } catch {
+    return null;
+  }
+}
+
+function readFileSafe(filePath) {
+  try {
+    return fs.readFileSync(filePath, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+function extractVersion(content, pattern) {
+  const match = content.match(pattern);
+  return match ? match[1] : '';
+}
+
+async function detect(repoPath) {
+  const abs = path.resolve(repoPath);
+  let primaryTech = '';
+  let framework = '';
+  let verifyCommands = '';
+  const stackParts = [];
+
+  // --- JS/TS: package.json ---
+  const pkgPath = path.join(abs, 'package.json');
+  if (await fs.pathExists(pkgPath)) {
+    const pkg = readJsonSafe(pkgPath);
+    if (pkg) {
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+      if (deps['@angular/core']) {
+        const ver = (deps['@angular/core'] || '').replace(/[~^]/g, '').split('.')[0];
+        primaryTech = 'TypeScript';
+        framework = `Angular ${ver}`;
+        verifyCommands = 'ng build, ng test, ng lint';
+        stackParts.push(`Angular ${ver}`);
+      } else if (deps.next) {
+        primaryTech = 'TypeScript/JS';
+        framework = 'Next.js';
+        verifyCommands = 'npm run build, npm run lint';
+        stackParts.push('Next.js');
+      } else if (deps.react) {
+        primaryTech = 'TypeScript/JS';
+        framework = 'React';
+        verifyCommands = 'npm run build, npm test';
+        stackParts.push('React');
+      } else if (deps.vue) {
+        primaryTech = 'TypeScript/JS';
+        framework = 'Vue.js';
+        verifyCommands = 'npm run build, npm test';
+        stackParts.push('Vue.js');
+      } else if (deps.svelte) {
+        primaryTech = 'TypeScript/JS';
+        framework = 'Svelte';
+        verifyCommands = 'npm run build, npm run check';
+        stackParts.push('Svelte');
+      } else if (deps.nuxt) {
+        primaryTech = 'TypeScript/JS';
+        framework = 'Nuxt';
+        verifyCommands = 'npm run build, npm run lint';
+        stackParts.push('Nuxt');
+      } else if (deps.express || deps.fastify || deps.koa || deps.hono) {
+        primaryTech = 'TypeScript/JS';
+        framework = 'Node.js';
+        verifyCommands = 'npm run build, npm test';
+        stackParts.push('Node.js');
+      }
+    }
+  }
+
+  // --- Java: pom.xml (Maven) ---
+  const pomPath = path.join(abs, 'pom.xml');
+  if (await fs.pathExists(pomPath)) {
+    const pom = readFileSafe(pomPath);
+
+    if (pom.includes('spring-boot-starter')) {
+      const sbVersion = extractVersion(pom, /spring-boot-starter-parent[\s\S]*?<version>([\d.]+)<\/version>/);
+      const javaVersion =
+        extractVersion(pom, /<java\.version>([\d.]+)<\/java\.version>/) ||
+        extractVersion(pom, /<maven\.compiler\.source>([\d.]+)<\/maven\.compiler\.source>/);
+
+      primaryTech = javaVersion ? `Java ${javaVersion}` : 'Java';
+      framework = sbVersion ? `Spring Boot ${sbVersion} + Maven` : 'Spring Boot + Maven';
+      verifyCommands = 'mvn compile, mvn test, mvn verify';
+      stackParts.push(sbVersion ? `Spring Boot ${sbVersion}` : 'Spring Boot');
+      stackParts.push('Maven');
+      if (javaVersion) stackParts.push(`Java ${javaVersion}`);
+
+      if (pom.includes('spring-boot-starter-data-jpa')) stackParts.push('JPA');
+      if (pom.includes('spring-cloud-starter-openfeign')) stackParts.push('Feign');
+      if (pom.includes('postgresql')) stackParts.push('PostgreSQL');
+      if (pom.includes('mysql-connector')) stackParts.push('MySQL');
+      if (pom.includes('spring-boot-starter-data-mongodb')) stackParts.push('MongoDB');
+    }
+  }
+
+  // --- Java/Kotlin: build.gradle(.kts) ---
+  if (!primaryTech) {
+    const gradleKts = path.join(abs, 'build.gradle.kts');
+    const gradleGroovy = path.join(abs, 'build.gradle');
+    const gradlePath = (await fs.pathExists(gradleKts)) ? gradleKts : (await fs.pathExists(gradleGroovy)) ? gradleGroovy : null;
+
+    if (gradlePath) {
+      const gradle = readFileSafe(gradlePath);
+      if (gradle.includes('org.springframework.boot')) {
+        primaryTech = gradlePath.endsWith('.kts') ? 'Kotlin' : 'Java/Kotlin';
+        framework = 'Spring Boot + Gradle';
+        verifyCommands = 'gradle build, gradle test';
+        stackParts.push('Spring Boot', 'Gradle');
+      }
+    }
+  }
+
+  // --- Python ---
+  if (!primaryTech) {
+    const pyprojectPath = path.join(abs, 'pyproject.toml');
+    const reqsPath = path.join(abs, 'requirements.txt');
+    let pyContent = '';
+
+    if (await fs.pathExists(pyprojectPath)) {
+      pyContent = readFileSafe(pyprojectPath);
+    } else if (await fs.pathExists(reqsPath)) {
+      pyContent = readFileSafe(reqsPath);
+    }
+
+    if (pyContent) {
+      const lower = pyContent.toLowerCase();
+      if (lower.includes('django')) {
+        primaryTech = 'Python';
+        framework = 'Django';
+        verifyCommands = 'python manage.py test';
+        stackParts.push('Django');
+      } else if (lower.includes('fastapi')) {
+        primaryTech = 'Python';
+        framework = 'FastAPI';
+        verifyCommands = 'pytest';
+        stackParts.push('FastAPI');
+      } else if (lower.includes('flask')) {
+        primaryTech = 'Python';
+        framework = 'Flask';
+        verifyCommands = 'pytest';
+        stackParts.push('Flask');
+      } else {
+        primaryTech = 'Python';
+        verifyCommands = 'pytest';
+        stackParts.push('Python');
+      }
+    }
+  }
+
+  // --- Go ---
+  if (!primaryTech) {
+    const goModPath = path.join(abs, 'go.mod');
+    if (await fs.pathExists(goModPath)) {
+      const goMod = readFileSafe(goModPath);
+      const goVer = extractVersion(goMod, /^go\s+([\d.]+)/m);
+      primaryTech = goVer ? `Go ${goVer}` : 'Go';
+      verifyCommands = 'go build ./..., go test ./...';
+      stackParts.push(primaryTech);
+    }
+  }
+
+  // --- Rust ---
+  if (!primaryTech) {
+    const cargoPath = path.join(abs, 'Cargo.toml');
+    if (await fs.pathExists(cargoPath)) {
+      primaryTech = 'Rust';
+      verifyCommands = 'cargo build, cargo test';
+      stackParts.push('Rust');
+    }
+  }
+
+  // --- Dart / Flutter ---
+  if (!primaryTech) {
+    const pubspecPath = path.join(abs, 'pubspec.yaml');
+    if (await fs.pathExists(pubspecPath)) {
+      const pubspec = readFileSafe(pubspecPath);
+      if (pubspec.includes('flutter')) {
+        primaryTech = 'Dart';
+        framework = 'Flutter';
+        verifyCommands = 'flutter analyze, flutter test';
+        stackParts.push('Flutter');
+      } else {
+        primaryTech = 'Dart';
+        verifyCommands = 'dart analyze, dart test';
+        stackParts.push('Dart');
+      }
+    }
+  }
+
+  // --- .NET ---
+  if (!primaryTech) {
+    const csprojFiles = await findFiles(abs, ['.csproj'], 1);
+    if (csprojFiles.length > 0) {
+      primaryTech = 'C#';
+      framework = '.NET';
+      verifyCommands = 'dotnet build, dotnet test';
+      stackParts.push('.NET');
+    }
+  }
+
+  // --- Ruby ---
+  if (!primaryTech) {
+    const gemfilePath = path.join(abs, 'Gemfile');
+    if (await fs.pathExists(gemfilePath)) {
+      const gemfile = readFileSafe(gemfilePath);
+      primaryTech = 'Ruby';
+      if (gemfile.includes('rails')) {
+        framework = 'Rails';
+        verifyCommands = 'rails test';
+        stackParts.push('Rails');
+      } else if (gemfile.includes('sinatra')) {
+        framework = 'Sinatra';
+        verifyCommands = 'ruby test/';
+        stackParts.push('Sinatra');
+      } else {
+        verifyCommands = 'ruby -c';
+        stackParts.push('Ruby');
+      }
+    }
+  }
+
+  // --- Supplementary ---
+  if (await fs.pathExists(path.join(abs, 'tsconfig.json'))) {
+    if (!stackParts.includes('TypeScript') && primaryTech !== 'TypeScript') {
+      stackParts.push('TypeScript');
+    }
+  }
+
+  const hasSCSS =
+    (await findFiles(abs, ['.scss'], 2)).length > 0;
+  if (hasSCSS) stackParts.push('SCSS');
+
+  const tailwindFiles = await findFiles(abs, ['tailwind.config.js', 'tailwind.config.ts', 'tailwind.config.mjs'], 1);
+  if (tailwindFiles.length > 0) stackParts.push('Tailwind CSS');
+
+  if (await fs.pathExists(pkgPath)) {
+    const pkgRaw = readFileSafe(pkgPath);
+    if (pkgRaw.includes('"bootstrap"')) stackParts.push('Bootstrap');
+    if (pkgRaw.includes('"@angular/material"')) stackParts.push('Angular Material');
+  }
+
+  if (await fs.pathExists(path.join(abs, 'Dockerfile'))) {
+    stackParts.push('Docker');
+  }
+
+  if (await fs.pathExists(path.join(abs, 'docker-compose.yml')) || await fs.pathExists(path.join(abs, 'docker-compose.yaml'))) {
+    if (!stackParts.includes('Docker')) stackParts.push('Docker');
+    stackParts.push('Docker Compose');
+  }
+
+  // --- Fallback ---
+  if (!primaryTech) {
+    primaryTech = 'Generic';
+  }
+
+  const stackCsv = stackParts.length > 0 ? stackParts.map((p) => sanitize(p, 50)).join(', ') : sanitize(primaryTech, 50);
+
+  return {
+    primaryTech: sanitize(primaryTech, 50),
+    framework: sanitize(framework, 100),
+    verifyCommands: sanitize(verifyCommands, 200),
+    stackParts: stackParts.map((p) => sanitize(p, 50)),
+    stackCsv,
+  };
+}
+
+function deriveAlias(repoPath) {
+  return path.basename(repoPath).replace(/[_.]/g, '-').slice(0, 30);
+}
+
+module.exports = { detect, deriveAlias, sanitize, findFiles };

package/src/core/template-engine.js

@@ -0,0 +1,31 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+const TEMPLATES_DIR = path.join(__dirname, '..', '..', 'templates', 'roles');
+
+function render(template, data) {
+  return template.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+    if (key in data) {
+      return data[key] ?? '';
+    }
+    return match;
+  });
+}
+
+async function renderFile(templateName, data) {
+  const filePath = path.join(TEMPLATES_DIR, templateName);
+  const template = await fs.readFile(filePath, 'utf8');
+  return render(template, data);
+}
+
+function listTemplates() {
+  if (!fs.existsSync(TEMPLATES_DIR)) {
+    return [];
+  }
+  return fs
+    .readdirSync(TEMPLATES_DIR)
+    .filter((f) => f.endsWith('.md.tmpl'))
+    .map((f) => f.replace('.md.tmpl', ''));
+}
+
+module.exports = { render, renderFile, listTemplates, TEMPLATES_DIR };

package/src/utils/logger.js

@@ -0,0 +1,57 @@
+const chalk = require('chalk');
+const ora = require('ora');
+
+let _quiet = false;
+
+const COLORS = {
+  primary: '#7C3AED',
+  success: '#10B981',
+  warning: '#F59E0B',
+  error: '#EF4444',
+  info: '#3B82F6',
+  muted: '#6B7280',
+};
+
+const NOOP = () => {};
+
+const log = {
+  info: (msg) => !_quiet && console.log(chalk.hex(COLORS.info)('ℹ'), msg),
+  success: (msg) => !_quiet && console.log(chalk.hex(COLORS.success)('✓'), msg),
+  warn: (msg) => !_quiet && console.log(chalk.hex(COLORS.warning)('⚠'), msg),
+  error: (msg) => !_quiet && console.log(chalk.hex(COLORS.error)('✗'), msg),
+  muted: (msg) => !_quiet && console.log(chalk.hex(COLORS.muted)(msg)),
+  label: (label, value) =>
+    !_quiet && console.log(chalk.hex(COLORS.muted)(label + ':'), chalk.white(value)),
+};
+
+const SPINNER_STUB = {
+  start() { return this; },
+  succeed() { return this; },
+  fail() { return this; },
+  stop() { return this; },
+};
+
+function spinner(text) {
+  if (_quiet) return SPINNER_STUB;
+  return ora({ text, color: 'magenta' });
+}
+
+function banner(version) {
+  if (_quiet) return;
+  const title = 'agent-factory';
+  const colored = title
+    .split('')
+    .map((c, i) => chalk.hex(i < 6 ? '#7C3AED' : '#A78BFA')(c))
+    .join('');
+  console.log(`\n  🏭 ${colored} ${chalk.gray(`v${version}`)}\n`);
+}
+
+function setQuiet(value) {
+  _quiet = !!value;
+}
+
+function isQuiet() {
+  return _quiet;
+}
+
+module.exports = { log, spinner, banner, setQuiet, isQuiet, COLORS, chalk };