@fredericboyer/dev-team 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dev-team contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/bin/dev-team.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+
+'use strict';
+
+const { run } = require('../lib/init');
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+if (command === 'init') {
+  run(process.cwd(), args.slice(1)).catch((err) => {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  });
+} else {
+  console.log('dev-team — Adversarial AI agent team for any project\n');
+  console.log('Usage:');
+  console.log('  npx dev-team init          Interactive onboarding wizard');
+  console.log('  npx dev-team init --all    Install everything with defaults');
+  console.log('');
+  process.exit(command === '--help' || command === '-h' ? 0 : 1);
+}

package/lib/files.js

@@ -0,0 +1,160 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Returns the absolute path to the templates/ directory within the package.
+ */
+function templateDir() {
+  return path.join(__dirname, '..', 'templates');
+}
+
+/**
+ * Copies a file from src to dest, creating parent directories as needed.
+ * Returns true if the file was written, false if skipped.
+ */
+function copyFile(src, dest) {
+  const dir = path.dirname(dest);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.copyFileSync(src, dest);
+  return true;
+}
+
+/**
+ * Checks if a file exists.
+ */
+function fileExists(absPath) {
+  try {
+    return fs.statSync(absPath).isFile();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Checks if a directory exists.
+ */
+function dirExists(absPath) {
+  try {
+    return fs.statSync(absPath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Reads a file and returns its content, or null if it doesn't exist.
+ */
+function readFile(absPath) {
+  try {
+    return fs.readFileSync(absPath, 'utf-8');
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Writes content to a file, creating parent directories as needed.
+ */
+function writeFile(absPath, content) {
+  const dir = path.dirname(absPath);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(absPath, content);
+}
+
+/**
+ * Deep merges hook configurations from source into target settings.
+ * Additive only — never removes existing hooks.
+ */
+function mergeSettings(existingPath, newFragment) {
+  let existing = {};
+  try {
+    existing = JSON.parse(fs.readFileSync(existingPath, 'utf-8'));
+  } catch {
+    // File doesn't exist or is invalid — start fresh
+  }
+
+  if (!existing.hooks) {
+    existing.hooks = {};
+  }
+
+  for (const [event, entries] of Object.entries(newFragment.hooks || {})) {
+    if (!existing.hooks[event]) {
+      existing.hooks[event] = entries;
+    } else {
+      // Add entries that don't already exist (by command string)
+      for (const newEntry of entries) {
+        const newCommands = (newEntry.hooks || []).map((h) => h.command);
+        const alreadyExists = existing.hooks[event].some((existingEntry) => {
+          const existingCommands = (existingEntry.hooks || []).map((h) => h.command);
+          return newCommands.every((cmd) => existingCommands.includes(cmd));
+        });
+        if (!alreadyExists) {
+          existing.hooks[event].push(newEntry);
+        }
+      }
+    }
+  }
+
+  fs.writeFileSync(existingPath, JSON.stringify(existing, null, 2) + '\n');
+}
+
+/**
+ * Appends content to a file with dev-team markers.
+ * If markers already exist, replaces content between them.
+ * If file doesn't exist, creates it with just the content.
+ */
+function mergeClaudeMd(filePath, newContent) {
+  const BEGIN_MARKER = '<!-- dev-team:begin -->';
+  const END_MARKER = '<!-- dev-team:end -->';
+
+  const existing = readFile(filePath);
+
+  if (!existing) {
+    // File doesn't exist — create with content
+    writeFile(filePath, newContent);
+    return 'created';
+  }
+
+  if (existing.includes(BEGIN_MARKER)) {
+    // Markers exist — replace between them
+    const beforeMarker = existing.substring(0, existing.indexOf(BEGIN_MARKER));
+    const afterMarker = existing.substring(existing.indexOf(END_MARKER) + END_MARKER.length);
+    writeFile(filePath, beforeMarker + newContent + afterMarker);
+    return 'replaced';
+  }
+
+  // No markers — append
+  writeFile(filePath, existing.trimEnd() + '\n\n' + newContent + '\n');
+  return 'appended';
+}
+
+/**
+ * Lists all files in a directory recursively.
+ */
+function listFilesRecursive(dir) {
+  const results = [];
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...listFilesRecursive(fullPath));
+    } else {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+
+module.exports = {
+  templateDir,
+  copyFile,
+  fileExists,
+  dirExists,
+  readFile,
+  writeFile,
+  mergeSettings,
+  mergeClaudeMd,
+  listFilesRecursive,
+};

package/lib/init.js

@@ -0,0 +1,206 @@
+'use strict';
+
+const path = require('path');
+const {
+  templateDir,
+  copyFile,
+  fileExists,
+  dirExists,
+  readFile,
+  writeFile,
+  mergeSettings,
+  mergeClaudeMd,
+} = require('./files');
+const prompts = require('./prompts');
+
+const ALL_AGENTS = [
+  { label: 'Voss', file: 'dev-team-voss.md', description: 'Backend Engineer' },
+  { label: 'Mori', file: 'dev-team-mori.md', description: 'Frontend/UI Engineer' },
+  { label: 'Szabo', file: 'dev-team-szabo.md', description: 'Security Auditor' },
+  { label: 'Knuth', file: 'dev-team-knuth.md', description: 'Quality Auditor' },
+  { label: 'Beck', file: 'dev-team-beck.md', description: 'Test Implementer' },
+  { label: 'Deming', file: 'dev-team-deming.md', description: 'Tooling & DX Optimizer' },
+];
+
+const QUALITY_HOOKS = [
+  { label: 'TDD enforcement', file: 'dev-team-tdd-enforce.js', description: 'Block implementation changes without tests' },
+  { label: 'Safety guard', file: 'dev-team-safety-guard.js', description: 'Block dangerous commands (rm -rf, force push)' },
+  { label: 'Post-change review', file: 'dev-team-post-change-review.js', description: 'Flag which agents should review after edits' },
+  { label: 'Pre-commit gate', file: 'dev-team-pre-commit-gate.js', description: 'Remind about reviews before committing' },
+  { label: 'Task loop', file: 'dev-team-task-loop.js', description: 'Iterative task loop with adversarial review gates' },
+];
+
+/**
+ * Main init flow.
+ */
+async function run(targetDir, flags = []) {
+  const isAll = flags.includes('--all');
+
+  console.log('\ndev-team — Adversarial AI agent team\n');
+
+  // Step 1: Detect existing state
+  const claudeDir = path.join(targetDir, '.claude');
+  const agentsDir = path.join(claudeDir, 'agents');
+  const hooksDir = path.join(claudeDir, 'hooks');
+  const skillsDir = path.join(claudeDir, 'skills');
+  const memoryDir = path.join(claudeDir, 'agent-memory');
+  const settingsPath = path.join(claudeDir, 'settings.json');
+  const claudeMdPath = path.join(targetDir, 'CLAUDE.md');
+  const prefsPath = path.join(claudeDir, 'dev-team.json');
+
+  console.log('Detected:');
+  console.log(`  .claude/ directory: ${dirExists(claudeDir) ? 'exists' : 'will be created'}`);
+  console.log(`  CLAUDE.md: ${fileExists(claudeMdPath) ? 'exists (will merge)' : 'will be created'}`);
+  console.log('');
+
+  // Step 2: Agent selection
+  let selectedAgents;
+  if (isAll) {
+    selectedAgents = ALL_AGENTS.map((a) => a.label);
+  } else {
+    selectedAgents = await prompts.checkbox(
+      'Which agents would you like to install?',
+      ALL_AGENTS.map((a) => ({
+        label: a.label,
+        description: `${a.description}`,
+        defaultSelected: true,
+      }))
+    );
+  }
+
+  // Step 3: Hook selection
+  let selectedHooks;
+  if (isAll) {
+    selectedHooks = QUALITY_HOOKS.map((h) => h.label);
+  } else {
+    selectedHooks = await prompts.checkbox(
+      'Which quality hooks do you want to enforce?',
+      QUALITY_HOOKS.map((h) => ({
+        label: h.label,
+        description: h.description,
+        defaultSelected: true,
+      }))
+    );
+  }
+
+  // Step 4: Copy agents
+  const templates = templateDir();
+  let agentCount = 0;
+
+  for (const agent of ALL_AGENTS) {
+    if (!selectedAgents.includes(agent.label)) continue;
+
+    const src = path.join(templates, 'agents', agent.file);
+    const dest = path.join(agentsDir, agent.file);
+
+    if (fileExists(dest) && !isAll) {
+      const overwrite = await prompts.confirm(`  ${agent.file} already exists. Overwrite?`, false);
+      if (!overwrite) continue;
+    }
+
+    copyFile(src, dest);
+    agentCount++;
+  }
+
+  // Step 5: Create agent memory directories
+  for (const agent of ALL_AGENTS) {
+    if (!selectedAgents.includes(agent.label)) continue;
+
+    const agentName = agent.file.replace('.md', '');
+    const memorySrc = path.join(templates, 'agent-memory', agentName, 'MEMORY.md');
+    const memoryDest = path.join(memoryDir, agentName, 'MEMORY.md');
+
+    if (!fileExists(memoryDest)) {
+      copyFile(memorySrc, memoryDest);
+    }
+  }
+
+  // Step 6: Create shared team learnings
+  const learningsSrc = path.join(templates, 'dev-team-learnings.md');
+  const learningsDest = path.join(claudeDir, 'dev-team-learnings.md');
+  if (!fileExists(learningsDest)) {
+    copyFile(learningsSrc, learningsDest);
+  }
+
+  // Step 7: Copy hooks
+  let hookCount = 0;
+
+  for (const hook of QUALITY_HOOKS) {
+    if (!selectedHooks.includes(hook.label)) continue;
+
+    const src = path.join(templates, 'hooks', hook.file);
+    const dest = path.join(hooksDir, hook.file);
+
+    if (fileExists(dest) && !isAll) {
+      const overwrite = await prompts.confirm(`  ${hook.file} already exists. Overwrite?`, false);
+      if (!overwrite) continue;
+    }
+
+    copyFile(src, dest);
+    hookCount++;
+  }
+
+  // Step 8: Merge hook settings
+  const settingsTemplate = JSON.parse(readFile(path.join(templates, 'settings.json')));
+
+  // Filter settings to only include selected hooks
+  const filteredSettings = { hooks: {} };
+  const selectedHookFiles = QUALITY_HOOKS
+    .filter((h) => selectedHooks.includes(h.label))
+    .map((h) => h.file);
+
+  for (const [event, entries] of Object.entries(settingsTemplate.hooks)) {
+    const filteredEntries = entries.map((entry) => ({
+      ...entry,
+      hooks: (entry.hooks || []).filter((h) =>
+        selectedHookFiles.some((f) => h.command && h.command.includes(f))
+      ),
+    })).filter((entry) => entry.hooks.length > 0);
+
+    if (filteredEntries.length > 0) {
+      filteredSettings.hooks[event] = filteredEntries;
+    }
+  }
+
+  mergeSettings(settingsPath, filteredSettings);
+
+  // Step 9: Copy skills
+  const skillsSrcDir = path.join(templates, 'skills');
+  const skillDirs = ['dev-team-challenge', 'dev-team-task'];
+  for (const skillDir of skillDirs) {
+    const src = path.join(skillsSrcDir, skillDir, 'SKILL.md');
+    const dest = path.join(skillsDir, skillDir, 'SKILL.md');
+    if (!fileExists(dest) || isAll) {
+      copyFile(src, dest);
+    }
+  }
+
+  // Step 10: Merge CLAUDE.md
+  const claudeMdTemplate = readFile(path.join(templates, 'CLAUDE.md'));
+  const claudeResult = mergeClaudeMd(claudeMdPath, claudeMdTemplate);
+
+  // Save preferences
+  const prefs = {
+    version: '0.1.0',
+    agents: selectedAgents,
+    hooks: selectedHooks,
+  };
+  writeFile(prefsPath, JSON.stringify(prefs, null, 2) + '\n');
+
+  // Step 11: Print summary
+  console.log('\nDone! Installed:\n');
+  console.log(`  Agents:    ${selectedAgents.join(', ')} (${agentCount} files)`);
+  console.log(`  Hooks:     ${selectedHooks.join(', ')} (${hookCount} files)`);
+  console.log(`  Skills:    challenge, task`);
+  console.log(`  Memory:    ${selectedAgents.length} agent memories + shared learnings`);
+  console.log(`  CLAUDE.md: ${claudeResult}`);
+  console.log(`  Settings:  ${settingsPath}`);
+  console.log('');
+  console.log('Next steps:');
+  console.log('  1. Review installed agents in .claude/agents/');
+  console.log('  2. Customize agent personas and focus areas to fit your project');
+  console.log('  3. Run @dev-team-deming to scan for additional tooling recommendations');
+  console.log('');
+}
+
+module.exports = { run };

package/lib/prompts.js

@@ -0,0 +1,123 @@
+'use strict';
+
+const readline = require('readline');
+
+/**
+ * Creates a readline interface for a single question, then closes it.
+ */
+function createInterface() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+}
+
+/**
+ * Asks a yes/no question. Returns true for yes.
+ */
+async function confirm(question, defaultYes = true) {
+  const rl = createInterface();
+  const hint = defaultYes ? '[Y/n]' : '[y/N]';
+
+  return new Promise((resolve) => {
+    rl.question(`${question} ${hint} `, (answer) => {
+      rl.close();
+      const trimmed = answer.trim().toLowerCase();
+      if (trimmed === '') {
+        resolve(defaultYes);
+      } else {
+        resolve(trimmed === 'y' || trimmed === 'yes');
+      }
+    });
+  });
+}
+
+/**
+ * Asks a checkbox-style question. Returns array of selected labels.
+ * Items: [{ label, description, defaultSelected }]
+ */
+async function checkbox(question, items) {
+  const rl = createInterface();
+
+  console.log(`\n${question}`);
+  items.forEach((item, i) => {
+    const checked = item.defaultSelected ? 'x' : ' ';
+    console.log(`  ${i + 1}. [${checked}] ${item.label} — ${item.description}`);
+  });
+
+  return new Promise((resolve) => {
+    rl.question('\nEnter numbers to toggle (e.g., 1 3 4), or press Enter for defaults: ', (answer) => {
+      rl.close();
+      const trimmed = answer.trim();
+
+      if (trimmed === '') {
+        // Use defaults
+        resolve(items.filter((item) => item.defaultSelected).map((item) => item.label));
+        return;
+      }
+
+      const toggled = new Set(
+        trimmed.split(/[\s,]+/).map(Number).filter((n) => n >= 1 && n <= items.length)
+      );
+
+      const selected = items
+        .filter((item, i) => {
+          const isDefault = item.defaultSelected;
+          const wasToggled = toggled.has(i + 1);
+          return isDefault ? !wasToggled : wasToggled;
+        })
+        .map((item) => item.label);
+
+      resolve(selected);
+    });
+  });
+}
+
+/**
+ * Asks a single-choice question. Returns the selected label.
+ * Options: [{ label, description }]
+ */
+async function select(question, options) {
+  const rl = createInterface();
+
+  console.log(`\n${question}`);
+  options.forEach((opt, i) => {
+    console.log(`  ${i + 1}. ${opt.label} — ${opt.description}`);
+  });
+
+  return new Promise((resolve) => {
+    rl.question('\nEnter number (default: 1): ', (answer) => {
+      rl.close();
+      const trimmed = answer.trim();
+
+      if (trimmed === '') {
+        resolve(options[0].label);
+        return;
+      }
+
+      const idx = Number(trimmed) - 1;
+      if (idx >= 0 && idx < options.length) {
+        resolve(options[idx].label);
+      } else {
+        resolve(options[0].label);
+      }
+    });
+  });
+}
+
+/**
+ * Asks for free-text input.
+ */
+async function input(question, defaultValue = '') {
+  const rl = createInterface();
+  const hint = defaultValue ? ` [${defaultValue}]` : '';
+
+  return new Promise((resolve) => {
+    rl.question(`${question}${hint}: `, (answer) => {
+      rl.close();
+      resolve(answer.trim() || defaultValue);
+    });
+  });
+}
+
+module.exports = { confirm, checkbox, select, input };

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@fredericboyer/dev-team",
+  "version": "0.1.0",
+  "description": "Adversarial AI agent team for any project — installs Claude Code agents, hooks, and skills that enforce quality through productive friction",
+  "bin": {
+    "dev-team": "./bin/dev-team.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "templates/"
+  ],
+  "scripts": {
+    "test": "node --test tests/unit/files.test.js tests/integration/fresh-project.test.js tests/integration/idempotency.test.js",
+    "test:unit": "node --test tests/unit/files.test.js",
+    "test:integration": "node --test tests/integration/fresh-project.test.js tests/integration/idempotency.test.js",
+    "test:scenarios": "node --test tests/scenarios/",
+    "lint": "eslint bin/ lib/ templates/hooks/",
+    "format:check": "prettier --check .",
+    "validate:agents": "node scripts/validate-agents.js"
+  },
+  "keywords": [
+    "claude-code",
+    "ai-agents",
+    "developer-tools",
+    "code-review",
+    "tdd",
+    "security"
+  ],
+  "author": "",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/templates/CLAUDE.md

@@ -0,0 +1,31 @@
+<!-- dev-team:begin -->
+
+## Dev Team
+
+This project uses [dev-team](https://github.com/dev-team) — adversarial AI agents that enforce quality through productive friction.
+
+### Agents
+
+| Agent | Role | When to use |
+|-------|------|-------------|
+| `@dev-team-voss` | Backend Engineer | API design, data modeling, system architecture, error handling |
+| `@dev-team-mori` | Frontend/UI Engineer | Components, accessibility, UX patterns, state management |
+| `@dev-team-szabo` | Security Auditor | Vulnerability review, auth flows, attack surface analysis |
+| `@dev-team-knuth` | Quality Auditor | Coverage gaps, boundary conditions, correctness verification |
+| `@dev-team-beck` | Test Implementer | Writing tests, TDD cycles, translating audit findings into test cases |
+| `@dev-team-deming` | Tooling Optimizer | Linters, formatters, CI/CD, hooks, onboarding, automation |
+
+### Workflow
+
+For non-trivial work: explore the area first, then implement, then review.
+
+Agents challenge each other using classified findings:
+- `[DEFECT]` blocks progress. `[RISK]`, `[QUESTION]`, `[SUGGESTION]` are advisory.
+- When agents disagree, they escalate to the human after one exchange each. Human decides.
+
+### Skills
+
+- `/dev-team:challenge` — critically examine a proposal or implementation
+- `/dev-team:task` — start an iterative task loop with adversarial review gates
+
+<!-- dev-team:end -->

package/templates/agent-memory/dev-team-beck/MEMORY.md

@@ -0,0 +1,12 @@
+# Agent Memory: Beck (Test Implementer)
+<!-- First 200 lines are loaded into agent context. Keep concise. -->
+
+## Test Patterns and Conventions
+
+
+## Framework and Runner Notes
+
+
+## Calibration Log
+<!-- Challenges accepted/overruled — tunes adversarial intensity over time -->
+

package/templates/agent-memory/dev-team-deming/MEMORY.md

@@ -0,0 +1,12 @@
+# Agent Memory: Deming (Tooling & DX Optimizer)
+<!-- First 200 lines are loaded into agent context. Keep concise. -->
+
+## Tooling Decisions
+
+
+## Hook Effectiveness
+
+
+## Calibration Log
+<!-- Challenges accepted/overruled — tunes adversarial intensity over time -->
+

package/templates/agent-memory/dev-team-knuth/MEMORY.md

@@ -0,0 +1,12 @@
+# Agent Memory: Knuth (Quality Auditor)
+<!-- First 200 lines are loaded into agent context. Keep concise. -->
+
+## Coverage Gaps Identified
+
+
+## Recurring Boundary Conditions
+
+
+## Calibration Log
+<!-- Challenges accepted/overruled — tunes adversarial intensity over time -->
+

package/templates/agent-memory/dev-team-mori/MEMORY.md

@@ -0,0 +1,12 @@
+# Agent Memory: Mori (Frontend/UI Engineer)
+<!-- First 200 lines are loaded into agent context. Keep concise. -->
+
+## Project Conventions
+
+
+## Patterns to Watch For
+
+
+## Calibration Log
+<!-- Challenges accepted/overruled — tunes adversarial intensity over time -->
+

package/templates/agent-memory/dev-team-szabo/MEMORY.md

@@ -0,0 +1,12 @@
+# Agent Memory: Szabo (Security Auditor)
+<!-- First 200 lines are loaded into agent context. Keep concise. -->
+
+## Trust Boundaries Mapped
+
+
+## Known Attack Surfaces
+
+
+## Calibration Log
+<!-- Challenges accepted/overruled — tunes adversarial intensity over time -->
+

package/templates/agent-memory/dev-team-voss/MEMORY.md

@@ -0,0 +1,12 @@
+# Agent Memory: Voss (Backend Engineer)
+<!-- First 200 lines are loaded into agent context. Keep concise. -->
+
+## Project Conventions
+
+
+## Patterns to Watch For
+
+
+## Calibration Log
+<!-- Challenges accepted/overruled — tunes adversarial intensity over time -->
+