@fredericboyer/dev-team 0.1.0

package/templates/hooks/dev-team-task-loop.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+
+/**
+ * dev-team-task-loop.js
+ * Stop hook — implements iterative task loop with adversarial review gates.
+ *
+ * When a task loop is active (.claude/dev-team-task.json exists):
+ * - Intercepts session exit
+ * - Checks if completion criteria are met (no [DEFECT] challenges)
+ * - If not met, feeds the task back for another iteration
+ * - Respects max iteration limit
+ *
+ * State file: .claude/dev-team-task.json (created by /dev-team:task skill)
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const STATE_FILE = path.join(process.cwd(), '.claude', 'dev-team-task.json');
+
+// No state file means no active task loop — allow normal exit
+if (!fs.existsSync(STATE_FILE)) {
+  process.exit(0);
+}
+
+let state;
+try {
+  state = JSON.parse(fs.readFileSync(STATE_FILE, 'utf-8'));
+} catch {
+  // Corrupted state file — clean up and allow exit
+  try { fs.unlinkSync(STATE_FILE); } catch { /* ignore */ }
+  process.exit(0);
+}
+
+const { prompt, iteration = 1, maxIterations = 10, sessionId } = state;
+
+// Check iteration limit
+if (iteration >= maxIterations) {
+  console.log(
+    `[dev-team task-loop] Max iterations (${maxIterations}) reached. Exiting loop. Review remaining issues manually.`
+  );
+  try { fs.unlinkSync(STATE_FILE); } catch { /* ignore */ }
+  process.exit(0);
+}
+
+// Increment iteration and update state
+state.iteration = iteration + 1;
+try {
+  fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+} catch {
+  // Can't write state — allow exit
+  process.exit(0);
+}
+
+// Block exit and re-inject the task prompt
+const output = JSON.stringify({
+  decision: 'block',
+  reason: prompt,
+  systemMessage: `[dev-team task-loop] Iteration ${iteration + 1}/${maxIterations}. Review findings and address any [DEFECT] challenges. When no [DEFECT] remains, output <promise>DONE</promise> to exit the loop. To cancel: delete .claude/dev-team-task.json`,
+});
+
+console.log(output);
+process.exit(0);

package/templates/hooks/dev-team-tdd-enforce.js

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+
+/**
+ * dev-team-tdd-enforce.js
+ * PostToolUse hook on Edit/Write.
+ *
+ * Blocks implementation file changes unless:
+ * - A test file has been modified in the current session, OR
+ * - A corresponding test file already exists (allows refactoring)
+ *
+ * New implementation files with no existing tests are blocked.
+ * Exit 2 = block, exit 0 = allow.
+ */
+
+'use strict';
+
+const { execFileSync } = require('child_process');
+const path = require('path');
+
+const input = JSON.parse(process.argv[2] || '{}');
+const filePath = (input.tool_input && (input.tool_input.file_path || input.tool_input.path)) || '';
+
+if (!filePath) {
+  process.exit(0);
+}
+
+const basename = path.basename(filePath);
+const ext = path.extname(filePath);
+
+// Skip non-code files
+const SKIP_EXTENSIONS = ['.md', '.json', '.yml', '.yaml', '.toml', '.txt', '.css', '.svg', '.png', '.jpg', '.gif', '.ico', '.lock'];
+if (SKIP_EXTENSIONS.includes(ext)) {
+  process.exit(0);
+}
+
+// Skip if the file IS a test file
+const TEST_PATTERNS = [
+  /\.test\./,
+  /\.spec\./,
+  /_test\./,
+  /\/__tests__\//,
+  /\/test\//,
+  /\/tests\//,
+];
+
+if (TEST_PATTERNS.some((p) => p.test(filePath))) {
+  process.exit(0);
+}
+
+// Skip config and non-implementation files
+const SKIP_PATTERNS = [
+  /\/config\//,
+  /\.config\./,
+  /\.env/,
+  /Dockerfile/,
+  /docker-compose/,
+  /\.github\//,
+  /\.claude\//,
+  /node_modules\//,
+];
+
+if (SKIP_PATTERNS.some((p) => p.test(filePath))) {
+  process.exit(0);
+}
+
+// Check if any test file has been modified in this session
+let changedFiles = '';
+try {
+  changedFiles = execFileSync('git', ['diff', '--name-only'], {
+    encoding: 'utf-8',
+    timeout: 5000,
+  });
+} catch {
+  // If git is not available or fails, allow the change
+  process.exit(0);
+}
+
+const hasTestChanges = changedFiles
+  .split('\n')
+  .filter(Boolean)
+  .some((f) => TEST_PATTERNS.some((p) => p.test(f)));
+
+if (hasTestChanges) {
+  // Tests were modified in this session — allow
+  process.exit(0);
+}
+
+// No test changes — check if a corresponding test file already exists.
+// This allows refactoring (modifying existing tested code) without
+// requiring the test file to also be modified.
+const fs = require('fs');
+const dir = path.dirname(filePath);
+const name = path.basename(filePath, ext);
+
+const CANDIDATE_PATTERNS = [
+  path.join(dir, `${name}.test${ext}`),
+  path.join(dir, `${name}.spec${ext}`),
+  path.join(dir, '__tests__', `${name}${ext}`),
+  path.join(dir, '__tests__', `${name}.test${ext}`),
+];
+
+const hasExistingTests = CANDIDATE_PATTERNS.some((candidate) => {
+  try { return fs.statSync(candidate).isFile(); } catch { return false; }
+});
+
+if (hasExistingTests) {
+  // Existing tests cover this file — allow refactoring
+  process.exit(0);
+}
+
+// No test changes AND no existing test file — block
+console.error(
+  `[dev-team tdd-enforce] TDD violation: "${basename}" modified but no corresponding test file exists. Write tests first.`
+);
+process.exit(2);

package/templates/settings.json

@@ -0,0 +1,50 @@
+{
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Edit|Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node .claude/hooks/dev-team-post-change-review.js"
+          },
+          {
+            "type": "command",
+            "command": "node .claude/hooks/dev-team-tdd-enforce.js"
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node .claude/hooks/dev-team-safety-guard.js"
+          }
+        ]
+      }
+    ],
+    "TaskCompleted": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node .claude/hooks/dev-team-pre-commit-gate.js"
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node .claude/hooks/dev-team-task-loop.js"
+          }
+        ]
+      }
+    ]
+  }
+}

package/templates/skills/dev-team-challenge/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: dev-team:challenge
+description: Challenge a proposed approach, implementation, or design decision. Use when the user says "challenge this", "what could go wrong", "play devil's advocate", or wants a critical review of an idea before committing to it.
+---
+
+Critically examine the following proposal or implementation: $ARGUMENTS
+
+Follow this structured review:
+
+## 1. Summarize the proposal
+State what is being proposed in one paragraph. Confirm your understanding before proceeding.
+
+## 2. Identify assumptions
+List every assumption the proposal relies on. For each assumption, state what would have to be true for it to hold.
+
+## 3. Find failure modes
+For each assumption, construct a concrete scenario where it breaks. Be specific — name inputs, conditions, or sequences that cause failure.
+
+## 4. Classify findings
+For each finding, classify it:
+- `[DEFECT]`: Concretely wrong. Will produce incorrect behavior.
+- `[RISK]`: Not wrong today, but creates a likely failure mode.
+- `[QUESTION]`: Decision needs justification.
+- `[SUGGESTION]`: Works, but here is a specific improvement.
+
+## 5. Verdict
+State one of:
+- **Proceed** — No blocking issues. Advisory findings noted.
+- **Revise** — `[DEFECT]` or significant `[RISK]` found. Address before proceeding.
+- **Reconsider** — Fundamental assumptions are flawed. Rethink the approach.

package/templates/skills/dev-team-task/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: dev-team:task
+description: Start an iterative task loop with adversarial review gates. Use when the user wants a task implemented with automatic quality convergence — the loop continues until no [DEFECT] challenges remain or max iterations are reached.
+---
+
+Start a task loop for: $ARGUMENTS
+
+## Setup
+
+1. Parse the task description and any flags:
+   - `--max-iterations N` (default: 10)
+   - `--reviewers` (default: @dev-team-szabo, @dev-team-knuth)
+
+2. Create the state file `.claude/dev-team-task.json`:
+```json
+{
+  "prompt": "<the original task description>",
+  "iteration": 1,
+  "maxIterations": <N>,
+  "reviewers": ["dev-team-szabo", "dev-team-knuth"]
+}
+```
+
+3. Determine the right implementing agent based on the task:
+   - Backend/API/data work → @dev-team-voss
+   - Frontend/UI work → @dev-team-mori
+   - Test writing → @dev-team-beck
+   - Tooling/config → @dev-team-deming
+
+## Execution loop
+
+Each iteration:
+1. The implementing agent works on the task.
+2. After implementation, spawn review agents in parallel as background tasks.
+3. Collect classified challenges from reviewers.
+4. If any `[DEFECT]` challenges exist, address them in the next iteration.
+5. If no `[DEFECT]` remains, output `<promise>DONE</promise>` to exit the loop.
+
+The Stop hook (`dev-team-task-loop.js`) manages iteration counting and re-injection.
+
+## Completion
+
+When the loop exits:
+1. Delete `.claude/dev-team-task.json`.
+2. Summarize what was accomplished across all iterations.
+3. Report any remaining `[RISK]` or `[SUGGESTION]` items for the human to review.
+4. Write key learnings to agent MEMORY.md files.