buildcrew 1.0.0 → 1.1.0

package/README.md

@@ -258,19 +258,6 @@ model: opus    # or sonnet, haiku
          └── Debug:    investigator
 ```
 
-## Compared to gstack
-
-| | buildcrew | gstack |
-|---|-----------|--------|
-| Install | `npx buildcrew` | `git clone` + Bun + `./setup` |
-| Orchestration | Auto (constitution routes) | Manual (`/qa`, `/review`, ...) |
-| Harness | `init` + `add` + custom .md | Manual CLAUDE.md |
-| Dependencies | None | Bun, Playwright binary (~58MB) |
-| Browser testing | Playwright MCP | Custom Playwright daemon |
-| Pipeline docs | Auto-generated chain (01→07) | Per-skill output |
-| Agents | 11 (5 opus, 6 sonnet) | 34 |
-| Customization | Edit .md directly, never overwritten | May overwrite on update |
-
 ## License
 
 MIT

package/bin/setup.js

@@ -3,14 +3,13 @@
 import { readdir, copyFile, mkdir, readFile, writeFile, access } from "fs/promises";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
-import { createInterface } from "readline";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const AGENTS_SRC = join(__dirname, "..", "agents");
 const TEMPLATES_SRC = join(__dirname, "..", "templates");
 const TARGET_DIR = join(process.cwd(), ".claude", "agents");
 const HARNESS_DIR = join(process.cwd(), ".claude", "harness");
-const VERSION = "1.0.0";
+const VERSION = "1.1.0";
 
 const RESET = "\x1b[0m";
 const BOLD = "\x1b[1m";
@@ -41,246 +40,330 @@ const TEMPLATES = {
   "env-vars":      { file: "env-vars.md",       desc: "Environment variables & secrets guide",      category: "system" },
 };
 
-// ─── Interactive prompt ───
-
-function createPrompt() {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  const ask = (q) => new Promise(resolve => rl.question(q, resolve));
-  const close = () => rl.close();
-  return { ask, close };
-}
-
-// ─── Auto-detect project info ───
+// ─── Deep auto-detect ───
 
 async function detectProject() {
-  const info = { name: "", stack: [], framework: "", hasTS: false, hasTailwind: false, hasI18n: false, hasAuth: false, hasDB: false };
+  const info = {
+    name: "", description: "", stack: [], framework: "",
+    hasTS: false, hasTailwind: false, hasI18n: false, hasAuth: false, hasDB: false,
+    hasPayments: false, hasAI: false, deploy: "", dbName: "", authName: "", paymentName: "",
+    components: [], apiRoutes: [], locales: [],
+  };
+
+  // package.json
   try {
     const pkg = JSON.parse(await readFile(join(process.cwd(), "package.json"), "utf8"));
     info.name = pkg.name || "";
+    info.description = pkg.description || "";
     const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+    // Framework
     if (allDeps["next"]) { info.framework = "Next.js"; info.stack.push("Next.js"); }
     else if (allDeps["nuxt"]) { info.framework = "Nuxt"; info.stack.push("Nuxt"); }
     else if (allDeps["react"]) { info.framework = "React"; info.stack.push("React"); }
     else if (allDeps["vue"]) { info.framework = "Vue"; info.stack.push("Vue"); }
     else if (allDeps["svelte"] || allDeps["@sveltejs/kit"]) { info.framework = "SvelteKit"; info.stack.push("SvelteKit"); }
     else if (allDeps["express"]) { info.framework = "Express"; info.stack.push("Express"); }
+
+    // Core
     if (allDeps["typescript"]) { info.hasTS = true; info.stack.push("TypeScript"); }
     if (allDeps["tailwindcss"]) { info.hasTailwind = true; info.stack.push("TailwindCSS"); }
-    if (allDeps["next-intl"] || allDeps["i18next"] || allDeps["react-intl"]) { info.hasI18n = true; info.stack.push("i18n"); }
-    if (allDeps["@supabase/supabase-js"]) { info.hasDB = true; info.stack.push("Supabase"); }
-    else if (allDeps["prisma"] || allDeps["@prisma/client"]) { info.hasDB = true; info.stack.push("Prisma"); }
-    else if (allDeps["drizzle-orm"]) { info.hasDB = true; info.stack.push("Drizzle"); }
-    if (allDeps["next-auth"] || allDeps["@auth/core"] || allDeps["@supabase/auth-helpers-nextjs"]) { info.hasAuth = true; info.stack.push("Auth"); }
-    if (allDeps["stripe"] || allDeps["@paddle/paddle-js"]) { info.stack.push("Payments"); }
+    if (allDeps["framer-motion"]) info.stack.push("Framer Motion");
+
+    // i18n
+    if (allDeps["next-intl"] || allDeps["i18next"] || allDeps["react-intl"] || allDeps["next-i18next"]) {
+      info.hasI18n = true; info.stack.push("i18n");
+    }
+
+    // DB
+    if (allDeps["@supabase/supabase-js"]) { info.hasDB = true; info.dbName = "Supabase"; info.stack.push("Supabase"); }
+    else if (allDeps["prisma"] || allDeps["@prisma/client"]) { info.hasDB = true; info.dbName = "Prisma"; info.stack.push("Prisma"); }
+    else if (allDeps["drizzle-orm"]) { info.hasDB = true; info.dbName = "Drizzle"; info.stack.push("Drizzle"); }
+    else if (allDeps["mongoose"]) { info.hasDB = true; info.dbName = "MongoDB"; info.stack.push("MongoDB"); }
+
+    // Auth
+    if (allDeps["next-auth"] || allDeps["@auth/core"]) { info.hasAuth = true; info.authName = "NextAuth"; info.stack.push("NextAuth"); }
+    else if (allDeps["@supabase/auth-helpers-nextjs"] || allDeps["@supabase/ssr"]) { info.hasAuth = true; info.authName = "Supabase Auth"; info.stack.push("Supabase Auth"); }
+    else if (allDeps["firebase"]) { info.hasAuth = true; info.authName = "Firebase Auth"; info.stack.push("Firebase"); }
+
+    // Payments
+    if (allDeps["stripe"]) { info.hasPayments = true; info.paymentName = "Stripe"; info.stack.push("Stripe"); }
+    else if (allDeps["@paddle/paddle-js"]) { info.hasPayments = true; info.paymentName = "Paddle"; info.stack.push("Paddle"); }
+    else if (allDeps["@tosspayments/payment-sdk"]) { info.hasPayments = true; info.paymentName = "Toss Payments"; info.stack.push("Toss Payments"); }
+
+    // AI
+    if (allDeps["openai"]) { info.hasAI = true; info.stack.push("OpenAI"); }
+    else if (allDeps["@anthropic-ai/sdk"]) { info.hasAI = true; info.stack.push("Anthropic"); }
+    else if (allDeps["@google/generative-ai"]) { info.hasAI = true; info.stack.push("Google AI"); }
   } catch {}
-  return info;
-}
 
-// ─── Add: copy template to harness ───
+  // Detect deploy from vercel.json / netlify.toml / fly.toml
+  if (await exists(join(process.cwd(), "vercel.json")) || await exists(join(process.cwd(), ".vercel"))) info.deploy = "Vercel";
+  else if (await exists(join(process.cwd(), "netlify.toml"))) info.deploy = "Netlify";
+  else if (await exists(join(process.cwd(), "fly.toml"))) info.deploy = "Fly.io";
+  else if (await exists(join(process.cwd(), "Dockerfile"))) info.deploy = "Docker";
 
-async function runAdd(type, force) {
-  if (!type) {
-    log(`\n  ${BOLD}Available harness templates:${RESET}\n`);
-    const categories = { core: "Core (auto-created by init)", data: "Data", system: "System", design: "Design", domain: "Domain" };
-    for (const [cat, label] of Object.entries(categories)) {
-      const items = Object.entries(TEMPLATES).filter(([, v]) => v.category === cat);
-      if (items.length === 0) continue;
-      log(`  ${CYAN}${label}${RESET}`);
-      for (const [name, info] of items) {
-        const installed = await exists(join(HARNESS_DIR, `${name}.md`));
-        const status = installed ? `${GREEN}installed${RESET}` : `${DIM}not installed${RESET}`;
-        log(`    ${BOLD}${name.padEnd(16)}${RESET} ${status}  ${DIM}${info.desc}${RESET}`);
-      }
-      log("");
+  // Scan components
+  try {
+    const compsDir = join(process.cwd(), "src", "components");
+    if (await exists(compsDir)) {
+      const files = await readdir(compsDir);
+      info.components = files.filter(f => f.endsWith(".tsx") || f.endsWith(".vue") || f.endsWith(".svelte")).map(f => f.replace(/\.\w+$/, ""));
     }
-    log(`  ${BOLD}Usage:${RESET} npx buildcrew add ${CYAN}<template>${RESET}`);
-    log(`  ${BOLD}Example:${RESET} npx buildcrew add erd\n`);
-    return;
-  }
-
-  const template = TEMPLATES[type];
-  if (!template) {
-    log(`\n  ${RED}Unknown template: ${type}${RESET}`);
-    log(`  ${DIM}Run ${BOLD}npx buildcrew add${RESET}${DIM} to see available templates.${RESET}\n`);
-    return;
-  }
+  } catch {}
 
-  if (!template.file) {
-    log(`\n  ${YELLOW}${type}.md is auto-generated by ${BOLD}npx buildcrew init${RESET}`);
-    log(`  ${DIM}Run init to create it, or create .claude/harness/${type}.md manually.${RESET}\n`);
-    return;
-  }
+  // Scan API routes
+  try {
+    const apiDir = join(process.cwd(), "src", "app", "api");
+    if (await exists(apiDir)) {
+      const scanDir = async (dir, prefix = "") => {
+        const entries = await readdir(dir, { withFileTypes: true });
+        const routes = [];
+        for (const e of entries) {
+          if (e.isDirectory()) routes.push(...await scanDir(join(dir, e.name), `${prefix}/${e.name}`));
+          else if (e.name === "route.ts" || e.name === "route.js") routes.push(prefix || "/");
+        }
+        return routes;
+      };
+      info.apiRoutes = await scanDir(apiDir);
+    }
+  } catch {}
 
-  const target = join(HARNESS_DIR, `${type}.md`);
-  if ((await exists(target)) && !force) {
-    log(`\n  ${YELLOW}${type}.md already exists.${RESET} Use ${BOLD}--force${RESET} to overwrite.\n`);
-    return;
-  }
+  // Scan i18n locales
+  try {
+    for (const localeDir of ["src/i18n/dictionaries", "src/locales", "locales", "messages", "public/locales"]) {
+      const dir = join(process.cwd(), localeDir);
+      if (await exists(dir)) {
+        const files = await readdir(dir);
+        info.locales = files.filter(f => f.endsWith(".json")).map(f => f.replace(".json", ""));
+        break;
+      }
+    }
+  } catch {}
 
-  await mkdir(HARNESS_DIR, { recursive: true });
-  await copyFile(join(TEMPLATES_SRC, template.file), target);
-  log(`\n  ${GREEN} + ${RESET} .claude/harness/${type}.md`);
-  log(`  ${DIM}Edit this file to fill in your project details.${RESET}`);
-  log(`  ${DIM}All agents will read it automatically.${RESET}\n`);
+  return info;
 }
 
-// ─── Init: Harness Engineering ───
+// ─── Init: Zero-question harness generation ───
 
 async function runInit(force) {
-  log(`\n  ${BOLD}buildcrew init${RESET} — Harness Engineering Setup\n`);
-  log(`  ${DIM}Setting up project context and team rules.${RESET}`);
-  log(`  ${DIM}All 11 agents will read these before every task.${RESET}\n`);
+  log(`\n  ${BOLD}buildcrew init${RESET} v${VERSION}\n`);
 
   if ((await exists(join(HARNESS_DIR, "project.md"))) && !force) {
     log(`  ${YELLOW}Harness already exists at .claude/harness/${RESET}`);
-    log(`  ${DIM}Use ${BOLD}npx buildcrew init --force${RESET}${DIM} to overwrite.${RESET}\n`);
+    log(`  ${DIM}Use ${BOLD}--force${RESET}${DIM} to regenerate. Or just edit the files directly.${RESET}\n`);
     return;
   }
 
-  const detected = await detectProject();
-  const { ask, close } = createPrompt();
+  log(`  ${DIM}Scanning project...${RESET}\n`);
+  const d = await detectProject();
 
-  try {
-    log(`  ${CYAN}${BOLD}[1/3] Project Context${RESET}\n`);
-    const name = (await ask(`  ${BOLD}Project name${RESET} ${DIM}(${detected.name || "none"})${RESET}: `)) || detected.name || "my-project";
-    const description = await ask(`  ${BOLD}What does this project do?${RESET} (1 sentence): `);
-    const stackAuto = detected.stack.length > 0 ? detected.stack.join(", ") : "not detected";
-    const stackExtra = await ask(`  ${BOLD}Tech stack${RESET} ${DIM}(detected: ${stackAuto})${RESET}\n  ${DIM}Add anything missing (comma-separated, or Enter):${RESET} `);
-    const deployTarget = await ask(`  ${BOLD}Deploy target${RESET} ${DIM}(Vercel, AWS, etc.)${RESET}: `);
-    const prodUrl = await ask(`  ${BOLD}Production URL${RESET} ${DIM}(or Enter to skip)${RESET}: `);
-
-    log(`\n  ${CYAN}${BOLD}[2/3] Team Rules${RESET}\n`);
-    const conventions = await ask(`  ${BOLD}Coding conventions${RESET}\n  ${DIM}(e.g., "functional components only, no default exports")${RESET}\n  : `);
-    const priorities = await ask(`  ${BOLD}What to prioritize${RESET}\n  ${DIM}(e.g., "UX over performance, security first")${RESET}\n  : `);
-    const avoid = await ask(`  ${BOLD}What to avoid${RESET}\n  ${DIM}(e.g., "no class components, no any types")${RESET}\n  : `);
-    const quality = await ask(`  ${BOLD}Quality standards${RESET}\n  ${DIM}(e.g., "all code must pass tsc, no console.log")${RESET}\n  : `);
-    const reviewRules = await ask(`  ${BOLD}Review rules${RESET}\n  ${DIM}(e.g., "always check auth on API routes, mobile-first")${RESET}\n  : `);
-
-    log(`\n  ${CYAN}${BOLD}[3/3] Domain Knowledge${RESET}\n`);
-    const domain = await ask(`  ${BOLD}Domain${RESET} ${DIM}(e.g., "e-commerce", "fintech")${RESET}: `);
-    const userTypes = await ask(`  ${BOLD}User types${RESET} ${DIM}(e.g., "free, premium, admin")${RESET}: `);
-    const keyTerms = await ask(`  ${BOLD}Key terms${RESET}\n  ${DIM}(e.g., "reading=tarot session, spread=card layout")${RESET}\n  : `);
-    const businessRules = await ask(`  ${BOLD}Business rules${RESET}\n  ${DIM}(e.g., "free=3 reads/day, premium=unlimited")${RESET}\n  : `);
-
-    close();
-
-    await mkdir(HARNESS_DIR, { recursive: true });
-    const fullStack = [...detected.stack, ...(stackExtra ? stackExtra.split(",").map(s => s.trim()) : [])].filter(Boolean);
-
-    const projectMd = `# Project: ${name}
+  await mkdir(HARNESS_DIR, { recursive: true });
+
+  // ─── project.md ───
+  const projectMd = `# Project: ${d.name || "my-project"}
 
 ## Overview
-${description || "[Edit: describe your project]"}
+${d.description || "<!-- Describe what this project does in 1-2 sentences -->"}
 
 ## Tech Stack
-${fullStack.map(s => `- ${s}`).join("\n") || "- [Edit: add your tech stack]"}
+${d.stack.map(s => `- ${s}`).join("\n") || "<!-- Add your tech stack -->"}
 
 ## Framework
-${detected.framework || "[Not detected]"}
+${d.framework || "<!-- Not detected -->"}
 
 ## Infrastructure
-- **Deploy**: ${deployTarget || "[Edit]"}
-- **Production URL**: ${prodUrl || "[Edit]"}
-- **TypeScript**: ${detected.hasTS ? "Yes" : "No"}
-- **CSS**: ${detected.hasTailwind ? "TailwindCSS" : "[Edit]"}
-- **i18n**: ${detected.hasI18n ? "Yes" : "No"}
-- **Auth**: ${detected.hasAuth ? "Yes" : "No"}
-- **Database**: ${detected.hasDB ? "Yes" : "No"}
+- **Deploy**: ${d.deploy || "<!-- Vercel / AWS / Netlify / etc. -->"}
+- **Production URL**: <!-- https://your-app.com -->
+- **TypeScript**: ${d.hasTS ? "Yes" : "No"}
+- **CSS**: ${d.hasTailwind ? "TailwindCSS" : "<!-- Your CSS solution -->"}
+- **i18n**: ${d.hasI18n ? `Yes (${d.locales.join(", ")})` : "No"}
+- **Auth**: ${d.hasAuth ? d.authName : "No"}
+- **Database**: ${d.hasDB ? d.dbName : "No"}
+- **Payments**: ${d.hasPayments ? d.paymentName : "No"}
+- **AI**: ${d.hasAI ? d.stack.find(s => ["OpenAI","Anthropic","Google AI"].includes(s)) || "Yes" : "No"}
+
+## Key Components
+${d.components.length > 0 ? d.components.map(c => `- ${c}`).join("\n") : "<!-- List your main components -->"}
+
+## API Routes
+${d.apiRoutes.length > 0 ? d.apiRoutes.map(r => `- \`/api${r}\``).join("\n") : "<!-- List your API endpoints -->"}
 
 ## Domain
-- **Industry**: ${domain || "[Edit]"}
-- **User types**: ${userTypes || "[Edit]"}
+- **Industry**: <!-- e.g., e-commerce, fintech, entertainment -->
+- **User types**: <!-- e.g., free users, premium users, admins -->
 
 ## Key Domain Terms
-${keyTerms ? keyTerms.split(",").map(t => `- ${t.trim()}`).join("\n") : "- [Edit: add domain-specific terms]"}
+<!-- Define project-specific terms so agents use consistent language -->
+<!-- - term = definition -->
 
 ## Business Rules
-${businessRules ? businessRules.split(",").map(r => `- ${r.trim()}`).join("\n") : "- [Edit: add business rules]"}
+<!-- Rules that affect feature development -->
+<!-- - Free users: 3 actions per day -->
+<!-- - Premium: unlimited access -->
 `;
 
-    const rulesMd = `# Team Rules
+  // ─── rules.md ───
+  const rulesMd = `# Team Rules
 
-These rules apply to ALL agents. Every agent reads this before starting work.
+All agents read this before every task. Edit freely.
 
 ## Coding Conventions
-${conventions ? conventions.split(",").map(c => `- ${c.trim()}`).join("\n") : "- Follow existing codebase patterns"}
+${d.framework === "Next.js" ? `- Use App Router patterns
+- Server components by default, "use client" only when needed
+- Functional components only` : "<!-- Add your coding conventions -->"}
+${d.hasTS ? "- Strict TypeScript — no \`any\` types" : ""}
+${d.hasTailwind ? "- Use TailwindCSS utility classes, avoid custom CSS" : ""}
+- No \`console.log\` in production code
+- No default exports (except pages/layouts)
 
 ## Priorities
-${priorities ? priorities.split(",").map(p => `- ${p.trim()}`).join("\n") : "- [Edit: set your priorities]"}
+- UX over premature optimization
+- Mobile-first responsive design
+${d.hasI18n ? `- i18n: all user-facing text must be in locale files (${d.locales.join(", ")})` : ""}
+${d.hasPayments ? "- Payment security: amounts validated server-side only" : ""}
 
 ## What to Avoid
-${avoid ? avoid.split(",").map(a => `- ${a.trim()}`).join("\n") : "- [Edit: list things to avoid]"}
+- Class components
+- \`any\` type assertions
+- Inline styles (use Tailwind or CSS modules)
+- Hardcoded strings in UI (use i18n)
+- Direct DB access from client components
 
 ## Quality Standards
-${quality ? quality.split(",").map(q => `- ${q.trim()}`).join("\n") : "- All code must pass type checker and linter\n- No debug logs in production"}
+${d.hasTS ? "- \`npx tsc --noEmit\` must pass" : ""}
+- \`npm run lint\` must pass
+- \`npm run build\` must pass
+${d.hasI18n && d.locales.length > 0 ? `- All ${d.locales.length} locale files must be in sync` : ""}
+- No unused imports or variables
 
 ## Review Standards
-${reviewRules ? reviewRules.split(",").map(r => `- ${r.trim()}`).join("\n") : "- [Edit: add review rules]"}
+${d.hasAuth ? "- All API routes must check authentication" : ""}
+${d.hasPayments ? "- Payment mutations must be server-side and atomic" : ""}
+${d.hasAI ? "- AI-generated content treated as untrusted (sanitize before render)" : ""}
+- Check for XSS on any user input rendering
+- Verify responsive layout at 375px, 768px, 1440px
 `;
 
-    await writeFile(join(HARNESS_DIR, "project.md"), projectMd);
-    await writeFile(join(HARNESS_DIR, "rules.md"), rulesMd);
-
-    log(`\n  ${GREEN}${BOLD}Harness created!${RESET}\n`);
-    log(`  ${GREEN} + ${RESET} .claude/harness/project.md`);
-    log(`  ${GREEN} + ${RESET} .claude/harness/rules.md`);
-
-    // Suggest additional templates
-    log(`\n  ${BOLD}Add more context with templates:${RESET}\n`);
-    const suggestions = [
-      ["erd",           "Database schema & relationships"],
-      ["architecture",  "System architecture overview"],
-      ["api-spec",      "API endpoints & contracts"],
-      ["design-system", "Colors, typography, components"],
-      ["glossary",      "Domain terms & user roles"],
-      ["user-flow",     "User journeys & page map"],
-      ["env-vars",      "Environment variables guide"],
-    ];
-    for (const [name, desc] of suggestions) {
-      log(`  ${DIM}npx buildcrew add ${CYAN}${name.padEnd(15)}${RESET} ${DIM}${desc}${RESET}`);
+  await writeFile(join(HARNESS_DIR, "project.md"), projectMd);
+  await writeFile(join(HARNESS_DIR, "rules.md"), rulesMd);
+
+  // Auto-add relevant templates
+  let templateCount = 0;
+  const autoTemplates = [];
+  if (d.hasDB) autoTemplates.push("erd");
+  if (d.apiRoutes.length > 0) autoTemplates.push("api-spec");
+  if (d.hasTailwind) autoTemplates.push("design-system");
+  if (d.hasI18n || d.components.length > 5) autoTemplates.push("user-flow");
+  autoTemplates.push("architecture");
+
+  for (const name of autoTemplates) {
+    const t = TEMPLATES[name];
+    if (t && t.file) {
+      await copyFile(join(TEMPLATES_SRC, t.file), join(HARNESS_DIR, `${name}.md`));
+      templateCount++;
     }
+  }
 
-    log(`\n  ${DIM}Or create any .md file in .claude/harness/ — agents read them all.${RESET}\n`);
+  // Print results
+  log(`  ${GREEN}${BOLD}Harness generated!${RESET} (${2 + templateCount} files)\n`);
+  log(`  ${GREEN} + ${RESET} project.md       ${DIM}auto-detected from package.json${RESET}`);
+  log(`  ${GREEN} + ${RESET} rules.md         ${DIM}smart defaults for ${d.framework || "your stack"}${RESET}`);
+  for (const name of autoTemplates) {
+    log(`  ${GREEN} + ${RESET} ${(name + ".md").padEnd(17)}${DIM}${TEMPLATES[name].desc}${RESET}`);
+  }
 
-    if (!(await exists(TARGET_DIR))) {
-      log(`  ${YELLOW}Agents not installed yet.${RESET} Run ${BOLD}npx buildcrew${RESET} first.\n`);
+  // Show what was detected
+  log(`\n  ${BOLD}Detected:${RESET}`);
+  if (d.stack.length > 0) log(`  ${CYAN}Stack${RESET}       ${d.stack.join(", ")}`);
+  if (d.deploy) log(`  ${CYAN}Deploy${RESET}      ${d.deploy}`);
+  if (d.components.length > 0) log(`  ${CYAN}Components${RESET}  ${d.components.length} found`);
+  if (d.apiRoutes.length > 0) log(`  ${CYAN}API Routes${RESET}  ${d.apiRoutes.length} found`);
+  if (d.locales.length > 0) log(`  ${CYAN}Locales${RESET}     ${d.locales.join(", ")}`);
+
+  // Available extras
+  const remaining = Object.entries(TEMPLATES).filter(([name, t]) => t.file && !autoTemplates.includes(name));
+  if (remaining.length > 0) {
+    log(`\n  ${BOLD}Add more:${RESET}`);
+    for (const [name, t] of remaining) {
+      log(`  ${DIM}npx buildcrew add ${CYAN}${name}${RESET}`);
     }
+  }
+
+  log(`\n  ${BOLD}Next step:${RESET} Edit ${CYAN}.claude/harness/*.md${RESET} to fill in project-specific details.`);
+  log(`  ${DIM}Look for <!-- comments --> — those are the parts to customize.${RESET}\n`);
+}
+
+// ─── Add: copy template ───
 
-  } catch (err) {
-    close();
-    throw err;
+async function runAdd(type, force) {
+  if (!type) {
+    log(`\n  ${BOLD}Available harness templates:${RESET}\n`);
+    const categories = { core: "Core (auto-created by init)", data: "Data", system: "System", design: "Design", domain: "Domain" };
+    for (const [cat, label] of Object.entries(categories)) {
+      const items = Object.entries(TEMPLATES).filter(([, v]) => v.category === cat);
+      if (items.length === 0) continue;
+      log(`  ${CYAN}${label}${RESET}`);
+      for (const [name, info] of items) {
+        const installed = await exists(join(HARNESS_DIR, `${name}.md`));
+        const status = installed ? `${GREEN}installed${RESET}` : `${DIM}not installed${RESET}`;
+        log(`    ${BOLD}${name.padEnd(16)}${RESET} ${status}  ${DIM}${info.desc}${RESET}`);
+      }
+      log("");
+    }
+    log(`  ${BOLD}Usage:${RESET} npx buildcrew add ${CYAN}<template>${RESET}\n`);
+    return;
+  }
+
+  const template = TEMPLATES[type];
+  if (!template) {
+    log(`\n  ${RED}Unknown template: ${type}${RESET}`);
+    log(`  ${DIM}Run ${BOLD}npx buildcrew add${RESET}${DIM} to see available templates.${RESET}\n`);
+    return;
   }
+
+  if (!template.file) {
+    log(`\n  ${YELLOW}${type}.md is auto-generated by ${BOLD}npx buildcrew init${RESET}\n`);
+    return;
+  }
+
+  const target = join(HARNESS_DIR, `${type}.md`);
+  if ((await exists(target)) && !force) {
+    log(`\n  ${YELLOW}${type}.md already exists.${RESET} Use ${BOLD}--force${RESET} to overwrite.\n`);
+    return;
+  }
+
+  await mkdir(HARNESS_DIR, { recursive: true });
+  await copyFile(join(TEMPLATES_SRC, template.file), target);
+  log(`\n  ${GREEN} + ${RESET} .claude/harness/${type}.md`);
+  log(`  ${DIM}Edit to fill in your project details. Agents read it automatically.${RESET}\n`);
 }
 
 // ─── Harness status ───
 
 async function runHarnessStatus() {
-  log(`\n  ${BOLD}Harness files${RESET} ${DIM}(.claude/harness/)${RESET}\n`);
+  log(`\n  ${BOLD}Harness${RESET} ${DIM}(.claude/harness/)${RESET}\n`);
 
   if (!(await exists(HARNESS_DIR))) {
-    log(`  ${YELLOW}No harness directory found.${RESET}`);
-    log(`  ${DIM}Run ${BOLD}npx buildcrew init${RESET}${DIM} to get started.${RESET}\n`);
+    log(`  ${YELLOW}No harness found.${RESET} Run ${BOLD}npx buildcrew init${RESET}\n`);
     return;
   }
 
   const files = (await readdir(HARNESS_DIR)).filter(f => f.endsWith(".md")).sort();
-  if (files.length === 0) {
-    log(`  ${YELLOW}Harness directory is empty.${RESET}\n`);
-    return;
-  }
+  if (files.length === 0) { log(`  ${YELLOW}Empty.${RESET}\n`); return; }
 
   for (const file of files) {
     const name = file.replace(".md", "");
-    const isTemplate = TEMPLATES[name];
     const content = await readFile(join(HARNESS_DIR, file), "utf8");
     const lines = content.split("\n").length;
-    const hasEdits = !content.includes("[Edit");
-    const status = hasEdits ? `${GREEN}configured${RESET}` : `${YELLOW}needs editing${RESET}`;
-    const desc = isTemplate ? `${DIM}${isTemplate.desc}${RESET}` : `${DIM}(custom)${RESET}`;
-    log(`  ${BOLD}${name.padEnd(16)}${RESET} ${status}  ${lines} lines  ${desc}`);
+    const hasComments = content.includes("<!--");
+    const status = hasComments ? `${YELLOW}needs editing${RESET}` : `${GREEN}configured${RESET}`;
+    const t = TEMPLATES[name];
+    const desc = t ? `${DIM}${t.desc}${RESET}` : `${DIM}(custom)${RESET}`;
+    log(`  ${BOLD}${name.padEnd(16)}${RESET} ${status}  ${DIM}${lines} lines${RESET}  ${desc}`);
   }
 
-  log(`\n  ${DIM}Agents read ALL .md files here. Add any file you want.${RESET}\n`);
+  log(`\n  ${DIM}Edit files to replace <!-- comments --> with your content.${RESET}\n`);
 }
 
 // ─── Install agents ───
@@ -288,78 +371,48 @@ async function runHarnessStatus() {
 async function runInstall(force) {
   const files = (await readdir(AGENTS_SRC)).filter(f => f.endsWith(".md"));
   log(`\n  ${BOLD}buildcrew${RESET} v${VERSION}\n  ${DIM}11 AI agents for Claude Code${RESET}\n`);
-  log(`${DIM}  Installing to ${TARGET_DIR}${RESET}\n`);
 
   await mkdir(TARGET_DIR, { recursive: true });
   let installed = 0, skipped = 0;
 
   for (const file of files) {
     const target = join(TARGET_DIR, file);
-    if ((await exists(target)) && !force) {
-      log(`  ${YELLOW}skip${RESET}  ${file} ${DIM}(exists, use --force)${RESET}`);
-      skipped++;
-      continue;
-    }
+    if ((await exists(target)) && !force) { skipped++; continue; }
     await copyFile(join(AGENTS_SRC, file), target);
-    log(`  ${GREEN} +  ${RESET} ${file}`);
+    log(`  ${GREEN} + ${RESET} ${file}`);
     installed++;
   }
 
   log("");
-  if (installed > 0) {
-    log(`  ${GREEN}${BOLD}Done!${RESET} ${installed} agents installed.${skipped > 0 ? ` ${skipped} skipped.` : ""}\n`);
-  } else {
-    log(`  ${YELLOW}All agents already exist.${RESET} Use ${BOLD}--force${RESET} to overwrite.\n`);
-  }
+  if (installed > 0) log(`  ${GREEN}${BOLD}Done!${RESET} ${installed} agents installed.${skipped > 0 ? ` ${skipped} skipped.` : ""}\n`);
+  else log(`  ${YELLOW}All agents already exist.${RESET} Use ${BOLD}--force${RESET} to overwrite.\n`);
 
-  const hasHarness = await exists(join(HARNESS_DIR, "project.md"));
-  if (!hasHarness) {
-    log(`  ${CYAN}Next:${RESET} Run ${BOLD}npx buildcrew init${RESET} to set up your project harness.\n`);
-  }
-
-  let hasPlaywright = false;
-  try {
-    const settingsPath = join(process.env.HOME, ".claude", "settings.json");
-    if (await exists(settingsPath)) {
-      hasPlaywright = (await readFile(settingsPath, "utf8")).includes("playwright");
-    }
-  } catch {}
-  if (!hasPlaywright) {
-    log(`  ${YELLOW}Optional:${RESET} Playwright MCP not detected.`);
-    log(`  ${DIM}Setup: claude mcp add playwright -- npx @anthropic-ai/mcp-server-playwright${RESET}\n`);
+  if (!(await exists(join(HARNESS_DIR, "project.md")))) {
+    log(`  ${CYAN}Next:${RESET} ${BOLD}npx buildcrew init${RESET} — auto-generates project harness from your codebase.\n`);
   }
 
-  log(`  ${BOLD}Quick start:${RESET}  @constitution [your request]\n`);
+  log(`  ${BOLD}Start:${RESET}  @constitution [your request]\n`);
 }
 
-// ─── List agents ───
+// ─── List / Uninstall ───
 
 async function runList() {
   const files = (await readdir(AGENTS_SRC)).filter(f => f.endsWith(".md"));
   log(`\n  ${BOLD}buildcrew${RESET} v${VERSION} — 11 agents\n`);
   for (const file of files) {
     const content = await readFile(join(AGENTS_SRC, file), "utf8");
-    const nameMatch = content.match(/^name:\s*(.+)$/m);
-    const descMatch = content.match(/^description:\s*(.+)$/m);
-    const modelMatch = content.match(/^model:\s*(.+)$/m);
-    const name = nameMatch ? nameMatch[1] : file.replace(".md", "");
-    const desc = descMatch ? descMatch[1] : "";
-    const model = modelMatch ? modelMatch[1] : "sonnet";
+    const name = (content.match(/^name:\s*(.+)$/m) || [])[1] || file.replace(".md", "");
+    const desc = (content.match(/^description:\s*(.+)$/m) || [])[1] || "";
+    const model = (content.match(/^model:\s*(.+)$/m) || [])[1] || "sonnet";
     const modelTag = model === "opus" ? `${MAGENTA}opus${RESET}` : `${DIM}sonnet${RESET}`;
-    const color = name === "constitution" ? BOLD : "";
-    log(`  ${color}${name.padEnd(20)}${RESET} ${modelTag}  ${DIM}${desc.slice(0, 55)}${RESET}`);
+    log(`  ${name === "constitution" ? BOLD : ""}${name.padEnd(20)}${RESET} ${modelTag}  ${DIM}${desc.slice(0, 55)}${RESET}`);
   }
   log("");
 }
 
-// ─── Uninstall ───
-
 async function runUninstall() {
   const files = (await readdir(AGENTS_SRC)).filter(f => f.endsWith(".md"));
-  if (!(await exists(TARGET_DIR))) {
-    log(`${YELLOW}No .claude/agents/ directory found.${RESET}`);
-    return;
-  }
+  if (!(await exists(TARGET_DIR))) { log(`${YELLOW}No agents found.${RESET}`); return; }
   let removed = 0;
   for (const file of files) {
     const target = join(TARGET_DIR, file);
@@ -376,38 +429,30 @@ async function main() {
   const subcommand = args[1];
   const force = args.includes("--force") || args.includes("-f");
 
-  if (args.includes("--version") || args.includes("-v")) {
-    log(`buildcrew v${VERSION}`);
-    return;
-  }
+  if (args.includes("--version") || args.includes("-v")) { log(`buildcrew v${VERSION}`); return; }
 
   if (args.includes("--help") || args.includes("-h")) {
     log(`
   ${BOLD}buildcrew${RESET} v${VERSION} — 11 AI agents for Claude Code
 
   ${BOLD}Commands:${RESET}
-    npx buildcrew                Install agents
-    npx buildcrew init           Set up project harness (interactive)
-    npx buildcrew add            List available harness templates
-    npx buildcrew add <template> Add a harness template
-    npx buildcrew harness        Show harness status
+    npx buildcrew              Install agents
+    npx buildcrew init         Auto-generate project harness (zero questions)
+    npx buildcrew add          List harness templates
+    npx buildcrew add <name>   Add a harness template
+    npx buildcrew harness      Show harness file status
 
   ${BOLD}Options:${RESET}
-    --force, -f      Overwrite existing files
-    --list, -l       List all agents
-    --uninstall      Remove installed agents
-    --version, -v    Show version
-
-  ${BOLD}Setup (recommended):${RESET}
-    ${GREEN}1.${RESET} npx buildcrew              ${DIM}Install agent files${RESET}
-    ${GREEN}2.${RESET} npx buildcrew init         ${DIM}Project context + team rules${RESET}
-    ${GREEN}3.${RESET} npx buildcrew add erd      ${DIM}Add more context (optional)${RESET}
-    ${GREEN}4.${RESET} @constitution [task]       ${DIM}Start working${RESET}
-
-  ${BOLD}Harness templates:${RESET}
-    erd, architecture, api-spec, design-system,
-    glossary, user-flow, env-vars
-    ${DIM}Or create any .md file in .claude/harness/${RESET}
+    --force, -f    Overwrite existing files
+    --list, -l     List all agents
+    --uninstall    Remove agents
+    --version      Show version
+
+  ${BOLD}Setup:${RESET}
+    ${GREEN}1.${RESET} npx buildcrew          ${DIM}Install agents${RESET}
+    ${GREEN}2.${RESET} npx buildcrew init     ${DIM}Auto-generate harness from codebase${RESET}
+    ${GREEN}3.${RESET} Edit .claude/harness/   ${DIM}Customize (replace <!-- comments -->)${RESET}
+    ${GREEN}4.${RESET} @constitution [task]   ${DIM}Start working${RESET}
 
   ${BOLD}More info:${RESET} https://github.com/z1nun/buildcrew
 `);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buildcrew",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "11 AI agents for Claude Code — auto-orchestrated dev team with 9 operating modes",
   "author": "z1nun",
   "license": "MIT",
@@ -11,6 +11,7 @@
   "files": [
     "bin/",
     "agents/",
+    "templates/",
     "README.md",
     "LICENSE"
   ],

package/templates/api-spec.md

@@ -0,0 +1,52 @@
+# API Specification
+
+## Base URL
+- **Development**: `http://localhost:3000/api`
+- **Production**: `https://[your-domain]/api`
+
+## Authentication
+- **Method**: [Bearer token / Cookie / API key]
+- **Header**: `Authorization: Bearer <token>`
+
+## Endpoints
+
+### [Resource Name]
+
+#### `GET /api/[resource]`
+- **Auth**: Required / Public
+- **Description**: [what it does]
+- **Query Params**: `?page=1&limit=20`
+- **Response 200**:
+```json
+{
+  "data": [],
+  "total": 0
+}
+```
+- **Response 401**: Unauthorized
+
+#### `POST /api/[resource]`
+- **Auth**: Required
+- **Body**:
+```json
+{
+  "field": "value"
+}
+```
+- **Response 201**: Created
+- **Response 400**: Validation error
+
+## Error Format
+```json
+{
+  "error": "Error message",
+  "code": "ERROR_CODE"
+}
+```
+
+## Rate Limits
+- [e.g., "100 requests per minute per user"]
+- [e.g., "AI endpoints: 10 requests per minute"]
+
+---
+*Agents use this to implement correct API calls, validate endpoints during review, and test during QA.*

package/templates/architecture.md

@@ -0,0 +1,49 @@
+# Architecture
+
+## System Overview
+
+```
+[Client] → [Frontend] → [API Layer] → [Database]
+                ↓              ↓
+           [Auth]         [External APIs]
+```
+
+## Frontend
+- **Framework**: [Next.js / React / Vue / etc.]
+- **Routing**: [App Router / Pages Router / file-based]
+- **State Management**: [React Context / Zustand / Redux / etc.]
+- **Styling**: [TailwindCSS / CSS Modules / styled-components]
+
+## Backend / API
+- **Type**: [Next.js API Routes / Express / serverless]
+- **Authentication**: [Supabase Auth / NextAuth / custom]
+- **Database**: [Supabase / PostgreSQL / MongoDB]
+- **ORM**: [Prisma / Drizzle / Supabase client]
+
+## External Services
+| Service | Purpose | Auth Method |
+|---------|---------|-------------|
+| [e.g., OpenAI] | [AI generation] | [API key] |
+| [e.g., Stripe] | [Payments] | [API key + webhook] |
+
+## Directory Structure
+```
+src/
+├── app/          [pages and API routes]
+├── components/   [React components]
+├── lib/          [utilities and helpers]
+└── [other dirs]
+```
+
+## Key Patterns
+- [e.g., "Server components by default, 'use client' only when needed"]
+- [e.g., "All DB access through lib/supabase/ helpers"]
+- [e.g., "API routes validate input with zod"]
+
+## Deploy
+- **Platform**: [Vercel / AWS / etc.]
+- **CI/CD**: [GitHub Actions / Vercel auto-deploy]
+- **Environments**: [dev, staging, prod]
+
+---
+*Agents use this to understand system boundaries, make architecture-consistent decisions, and avoid breaking existing patterns.*

package/templates/design-system.md

@@ -0,0 +1,66 @@
+# Design System
+
+## Colors
+
+### Brand
+| Token | Value | Usage |
+|-------|-------|-------|
+| `primary` | [#hex] | CTAs, links, active states |
+| `secondary` | [#hex] | Secondary buttons, borders |
+| `accent` | [#hex] | Highlights, badges |
+
+### Semantic
+| Token | Value | Usage |
+|-------|-------|-------|
+| `success` | [#hex] | Success messages, confirmations |
+| `error` | [#hex] | Error messages, destructive actions |
+| `warning` | [#hex] | Warnings, caution states |
+| `info` | [#hex] | Informational messages |
+
+### Neutral
+| Token | Value | Usage |
+|-------|-------|-------|
+| `bg` | [#hex] | Page background |
+| `surface` | [#hex] | Card/modal backgrounds |
+| `border` | [#hex] | Borders, dividers |
+| `text` | [#hex] | Primary text |
+| `text-muted` | [#hex] | Secondary text, labels |
+
+## Typography
+
+| Level | Size | Weight | Line Height | Usage |
+|-------|------|--------|-------------|-------|
+| H1 | [rem] | [weight] | [lh] | Page titles |
+| H2 | [rem] | [weight] | [lh] | Section titles |
+| H3 | [rem] | [weight] | [lh] | Card titles |
+| Body | [rem] | [weight] | [lh] | Default text |
+| Small | [rem] | [weight] | [lh] | Captions, labels |
+
+## Spacing
+- **Base unit**: [4px / 8px]
+- **Scale**: 4, 8, 12, 16, 24, 32, 48, 64
+
+## Border Radius
+- **Small**: [4px] — inputs, small cards
+- **Medium**: [8px] — cards, modals
+- **Large**: [16px] — large containers
+- **Full**: [9999px] — pills, avatars
+
+## Shadows
+- **Small**: [shadow] — hover states
+- **Medium**: [shadow] — cards, dropdowns
+- **Large**: [shadow] — modals, popovers
+
+## Components
+| Component | Variants | Location |
+|-----------|----------|----------|
+| Button | primary, secondary, ghost, destructive | `src/components/Button` |
+| [Component] | [variants] | [path] |
+
+## Animation
+- **Duration**: fast (150ms), normal (300ms), slow (500ms)
+- **Easing**: ease-out for enter, ease-in for exit
+- **Library**: [Framer Motion / CSS transitions / etc.]
+
+---
+*Agents use this to create visually consistent components, pick correct tokens, and follow established patterns.*

package/templates/env-vars.md

@@ -0,0 +1,36 @@
+# Environment Variables
+
+## Required (app won't work without these)
+
+| Variable | Description | Where to Get |
+|----------|-------------|-------------|
+| `DATABASE_URL` | [Database connection string] | [Supabase dashboard / provider] |
+| `NEXT_PUBLIC_SUPABASE_URL` | [Supabase project URL] | [Supabase dashboard] |
+| `NEXT_PUBLIC_SUPABASE_ANON_KEY` | [Supabase public key] | [Supabase dashboard] |
+| | | |
+
+## Optional (features degrade gracefully)
+
+| Variable | Description | Feature Affected |
+|----------|-------------|-----------------|
+| `OPENAI_API_KEY` | [AI API access] | [AI features disabled] |
+| `STRIPE_SECRET_KEY` | [Payment processing] | [Payments disabled] |
+| | | |
+
+## Server-Only (never expose to client)
+
+| Variable | Why Server-Only |
+|----------|----------------|
+| `SUPABASE_SERVICE_ROLE_KEY` | Bypasses RLS |
+| `[API]_SECRET_KEY` | Payment/API secrets |
+
+## Environments
+
+| Env | .env file | Notes |
+|-----|-----------|-------|
+| Local | `.env.local` | Never committed |
+| Preview | Vercel env vars | Auto from branch |
+| Production | Vercel env vars | Manual setup |
+
+---
+*Agents use this to avoid exposing secrets, configure features correctly, and debug environment issues.*

package/templates/erd.md

@@ -0,0 +1,32 @@
+# ERD (Entity Relationship Diagram)
+
+## Tables
+
+### users
+| Column | Type | Constraints | Description |
+|--------|------|-------------|-------------|
+| id | uuid | PK | |
+| email | text | unique, not null | |
+| created_at | timestamp | default now() | |
+
+### [table_name]
+| Column | Type | Constraints | Description |
+|--------|------|-------------|-------------|
+
+## Relationships
+
+```
+users 1──* orders      (one user has many orders)
+orders *──1 products   (many orders reference one product)
+```
+
+## Indexes
+- `users.email` — unique index for login lookup
+- [add your indexes]
+
+## RLS Policies (if using Supabase)
+- `users`: users can only read/update their own row
+- [add your policies]
+
+---
+*Agents use this to understand your data model when planning features, writing queries, and reviewing security.*

package/templates/glossary.md

@@ -0,0 +1,27 @@
+# Glossary
+
+Domain terms and their definitions. All agents use consistent terminology.
+
+| Term | Definition | In Code As |
+|------|-----------|------------|
+| [e.g., reading] | [e.g., A tarot card reading session] | `Reading` type |
+| [e.g., spread] | [e.g., The layout pattern for cards] | `SpreadType` enum |
+| [e.g., interpretation] | [e.g., AI-generated meaning of cards] | `Interpretation` type |
+| | | |
+| | | |
+
+## User Roles
+| Role | Permissions | In Code As |
+|------|------------|------------|
+| [e.g., free user] | [e.g., 3 readings per day] | `role: "free"` |
+| [e.g., premium] | [e.g., unlimited readings + chat] | `role: "premium"` |
+| [e.g., admin] | [e.g., all access + user management] | `role: "admin"` |
+
+## Status Flows
+```
+[e.g., Order: draft → pending → paid → fulfilled → completed]
+[e.g., User: anonymous → registered → verified → premium]
+```
+
+---
+*Agents use this to write code with correct naming, understand business logic, and communicate clearly in docs.*

package/templates/user-flow.md

@@ -0,0 +1,40 @@
+# User Flows
+
+## Core Flows
+
+### [Flow Name, e.g., "Purchase Flow"]
+```
+[Entry Point] → [Step 1] → [Step 2] → [Step 3] → [Success]
+                    ↓           ↓           ↓
+                [Error A]   [Error B]   [Error C]
+```
+
+**Happy Path**:
+1. User [action]
+2. System [response]
+3. User [action]
+4. System [response] → Success
+
+**Error Paths**:
+- Step 1 fails: [what happens, where user goes]
+- Step 2 fails: [what happens]
+- Network error: [retry? fallback?]
+
+**Edge Cases**:
+- [e.g., user refreshes mid-flow]
+- [e.g., session expires during checkout]
+- [e.g., concurrent access from two devices]
+
+### [Next Flow...]
+
+## Page Map
+```
+/                 → Home (landing)
+/login            → Auth
+/dashboard        → Main dashboard (auth required)
+/dashboard/[id]   → Detail page
+/settings         → User settings
+```
+
+---
+*Agents use this to implement correct navigation, handle all error states, and test edge cases during QA.*