ai-squad 0.1.0

package/dist/index.js

@@ -0,0 +1,1013 @@
+#!/usr/bin/env node
+
+// src/wizard.ts
+import {
+  intro,
+  outro,
+  text,
+  select,
+  multiselect,
+  spinner,
+  isCancel,
+  cancel,
+  note
+} from "@clack/prompts";
+import pc2 from "picocolors";
+
+// src/squads.ts
+var SQUADS = [
+  {
+    id: "solo",
+    name: "Solo",
+    description: "One developer, quick projects. Full-stack dev + reviewer.",
+    agents: ["fullstack-dev", "reviewer"]
+  },
+  {
+    id: "startup",
+    name: "Startup",
+    description: "Small team, fast iteration. PO + dev + reviewer + QA.",
+    agents: ["po", "fullstack-dev", "reviewer", "qa"]
+  },
+  {
+    id: "standard",
+    name: "Standard",
+    description: "Production apps. PO + architect + dev + reviewer + UX + QA.",
+    agents: ["po", "architect", "fullstack-dev", "reviewer", "ux-ui", "qa"]
+  },
+  {
+    id: "enterprise",
+    name: "Enterprise",
+    description: "High-stakes, compliance. All 9 agents.",
+    agents: [
+      "po",
+      "architect",
+      "fullstack-dev",
+      "reviewer",
+      "ux-ui",
+      "qa",
+      "adversarial-reviewer",
+      "docs-writer",
+      "memory-keeper"
+    ]
+  },
+  {
+    id: "frontend",
+    name: "Frontend",
+    description: "UI-heavy projects. Dev + UX + reviewer.",
+    agents: ["fullstack-dev", "ux-ui", "reviewer"]
+  },
+  {
+    id: "backend",
+    name: "Backend",
+    description: "API/DB projects. Architect + dev + reviewer + QA.",
+    agents: ["architect", "fullstack-dev", "reviewer", "qa"]
+  }
+];
+function getSquad(id) {
+  return SQUADS.find((s) => s.id === id);
+}
+var PLATFORMS = ["opencode"];
+
+// src/features.ts
+var FEATURE_MAP = {
+  minimal: { state: false, tasks: false, memory: false, context: false, sessions: false },
+  essential: { state: true, tasks: true, memory: false, context: false, sessions: false },
+  standard: { state: true, tasks: true, memory: true, context: true, sessions: false },
+  comprehensive: { state: true, tasks: true, memory: true, context: true, sessions: true }
+};
+var INFRA_AGENTS = {
+  minimal: [],
+  essential: [],
+  standard: ["memory-keeper"],
+  comprehensive: ["memory-keeper", "docs-writer"]
+};
+function getInfraAgents(level) {
+  return INFRA_AGENTS[level];
+}
+function getOrchestratorInfra(squadAgents) {
+  if (squadAgents.includes("po")) {
+    return ["teamlead"];
+  }
+  return [];
+}
+function resolveFeatures(level) {
+  return { ...FEATURE_MAP[level] };
+}
+
+// src/skills-map.ts
+var SKILL_SOURCES = {
+  nextjs: [
+    {
+      source: "vercel-labs/agent-skills",
+      skills: ["react-best-practices", "composition-patterns", "react-view-transitions"],
+      description: "React/Next.js best practices: 40+ rules, composition patterns, view transitions"
+    },
+    {
+      source: "shadcn/ui",
+      skills: ["shadcn"],
+      description: "shadcn/ui component usage, theming, and Tailwind integration"
+    }
+  ],
+  react: [
+    {
+      source: "vercel-labs/agent-skills",
+      skills: ["react-best-practices", "composition-patterns", "react-view-transitions"],
+      description: "React best practices: 40+ rules across 8 categories"
+    },
+    {
+      source: "shadcn/ui",
+      skills: ["shadcn"],
+      description: "shadcn/ui component usage, theming, and Tailwind integration"
+    }
+  ],
+  typescript: [
+    {
+      source: "mattpocock/skills",
+      description: "TypeScript engineering skills: code review, debugging, TDD, domain modeling"
+    }
+  ],
+  tailwind: [
+    {
+      source: "vercel-labs/agent-skills",
+      skills: ["web-design-guidelines"],
+      description: "100+ UI design rules including Tailwind patterns"
+    },
+    {
+      source: "shadcn/ui",
+      skills: ["shadcn"],
+      description: "shadcn/ui component usage, theming, and Tailwind integration"
+    }
+  ],
+  python: [],
+  fastapi: [],
+  express: [],
+  go: [],
+  convex: [
+    {
+      source: "get-convex/agent-skills",
+      skills: ["convex-quickstart", "convex-setup-auth", "convex-create-component", "convex-migration-helper"],
+      description: "Official Convex skills: schema, auth, components, migrations"
+    }
+  ],
+  cloudflare: [],
+  generic: []
+};
+function getSkillsForStack(stack) {
+  const skillMap = /* @__PURE__ */ new Map();
+  for (const tech of stack) {
+    const sources = SKILL_SOURCES[tech.toLowerCase()];
+    if (sources) {
+      for (const src of sources) {
+        const existing = skillMap.get(src.source) ?? /* @__PURE__ */ new Set();
+        if (src.skills) {
+          for (const sk of src.skills) existing.add(sk);
+        }
+        skillMap.set(src.source, existing);
+      }
+    }
+  }
+  return Array.from(skillMap.entries()).map(([source, skills]) => ({
+    source,
+    skills: skills.size > 0 ? [...skills].sort() : void 0,
+    directory: `.agents/skills/${source.split("/").pop()}`
+  }));
+}
+function getTechStacks() {
+  return Object.keys(SKILL_SOURCES);
+}
+function getSkillInstallCommands(skills) {
+  return skills.map((s) => {
+    if (s.skills && s.skills.length > 0) {
+      const skillFlags = s.skills.map((sk) => `--skill ${sk}`).join(" ");
+      return `npx skills add ${s.source} -a opencode ${skillFlags} -y`;
+    }
+    return `npx skills add ${s.source} -a opencode -y`;
+  });
+}
+
+// src/builders/agent.ts
+import { parse as parseYaml } from "yaml";
+
+// src/compose.ts
+import { stringify as stringifyYaml } from "yaml";
+function filterSections(registry, ctx) {
+  return registry.filter((s) => !s.condition || s.condition(ctx)).sort((a, b) => {
+    if (a.priority !== b.priority) return a.priority - b.priority;
+    return a.id.localeCompare(b.id);
+  });
+}
+function buildAgentBody(sections) {
+  return sections.map((s) => s.trim()).filter(Boolean).join("\n\n");
+}
+function buildAgentFile(frontmatter, body) {
+  const fm = {
+    name: frontmatter.name,
+    description: frontmatter.description,
+    mode: frontmatter.mode,
+    hidden: frontmatter.hidden,
+    color: frontmatter.color
+  };
+  const yamlBlock = stringifyYaml(fm).trim();
+  return `---
+${yamlBlock}
+---
+
+${body.trim()}
+`;
+}
+
+// src/conditions.ts
+function hasFeature(feature) {
+  return (ctx) => ctx.features[feature];
+}
+function hasStack(tech) {
+  return (ctx) => ctx.stack.includes(tech);
+}
+function isAgent(agent) {
+  return (ctx) => ctx.agent === agent;
+}
+
+// src/registry.ts
+var AGENT_WORKFLOW_SECTIONS = [
+  {
+    id: "workflow-tasks",
+    file: "agents/workflow/tasks.md",
+    base: "platform",
+    priority: 100,
+    condition: hasFeature("tasks")
+  },
+  {
+    id: "workflow-memory",
+    file: "agents/workflow/memory.md",
+    base: "platform",
+    priority: 110,
+    condition: hasFeature("memory")
+  },
+  {
+    id: "workflow-context",
+    file: "agents/workflow/context.md",
+    base: "platform",
+    priority: 120,
+    condition: hasFeature("context")
+  },
+  {
+    id: "workflow-sessions",
+    file: "agents/workflow/sessions.md",
+    base: "platform",
+    priority: 130,
+    condition: hasFeature("sessions")
+  }
+];
+var STACK_SECTIONS = [
+  {
+    id: "stack-typescript",
+    file: "agents/standards/typescript.md",
+    base: "platform",
+    priority: 200,
+    condition: hasStack("typescript")
+  },
+  {
+    id: "stack-nextjs",
+    file: "agents/standards/nextjs.md",
+    base: "platform",
+    priority: 210,
+    condition: hasStack("nextjs")
+  },
+  {
+    id: "stack-react",
+    file: "agents/standards/react.md",
+    base: "platform",
+    priority: 220,
+    condition: hasStack("react")
+  },
+  {
+    id: "stack-python",
+    file: "agents/standards/python.md",
+    base: "platform",
+    priority: 230,
+    condition: hasStack("python")
+  },
+  {
+    id: "stack-generic",
+    file: "agents/standards/generic.md",
+    base: "platform",
+    priority: 240
+  }
+];
+var IDENTITY_SECTIONS = [
+  {
+    id: "identity-fullstack-dev",
+    file: "agents/identity/fullstack-dev.md",
+    base: "platform",
+    priority: 0,
+    condition: isAgent("fullstack-dev")
+  },
+  {
+    id: "identity-reviewer",
+    file: "agents/identity/reviewer.md",
+    base: "platform",
+    priority: 0,
+    condition: isAgent("reviewer")
+  },
+  {
+    id: "identity-po",
+    file: "agents/identity/po.md",
+    base: "platform",
+    priority: 0,
+    condition: isAgent("po")
+  },
+  {
+    id: "identity-architect",
+    file: "agents/identity/architect.md",
+    base: "platform",
+    priority: 0,
+    condition: isAgent("architect")
+  },
+  {
+    id: "identity-ux-ui",
+    file: "agents/identity/ux-ui.md",
+    base: "platform",
+    priority: 0,
+    condition: isAgent("ux-ui")
+  },
+  {
+    id: "identity-qa",
+    file: "agents/identity/qa.md",
+    base: "platform",
+    priority: 0,
+    condition: isAgent("qa")
+  },
+  {
+    id: "identity-adversarial-reviewer",
+    file: "agents/identity/adversarial-reviewer.md",
+    base: "platform",
+    priority: 0,
+    condition: isAgent("adversarial-reviewer")
+  },
+  {
+    id: "identity-docs-writer",
+    file: "agents/identity/docs-writer.md",
+    base: "platform",
+    priority: 0,
+    condition: isAgent("docs-writer")
+  },
+  {
+    id: "identity-memory-keeper",
+    file: "agents/identity/memory-keeper.md",
+    base: "platform",
+    priority: 0,
+    condition: isAgent("memory-keeper")
+  },
+  {
+    id: "identity-teamlead",
+    file: "agents/identity/teamlead.md",
+    base: "platform",
+    priority: 0,
+    condition: isAgent("teamlead")
+  }
+];
+function getAgentSections(platform) {
+  return [
+    ...IDENTITY_SECTIONS,
+    ...AGENT_WORKFLOW_SECTIONS,
+    ...STACK_SECTIONS
+  ];
+}
+
+// src/utils/cache.ts
+import { readFile } from "fs/promises";
+var cache = /* @__PURE__ */ new Map();
+async function loadTemplate(filePath) {
+  const cached = cache.get(filePath);
+  if (cached !== void 0) return cached;
+  const content = await readFile(filePath, "utf-8");
+  cache.set(filePath, content);
+  return content;
+}
+function clearCache() {
+  cache.clear();
+}
+
+// src/utils/resolve.ts
+function resolveVars(text2, vars) {
+  const unresolved = [];
+  const resolved = text2.replace(/\$\{(\w+)\}/g, (match, key) => {
+    if (!(key in vars)) {
+      unresolved.push(key);
+      return match;
+    }
+    return vars[key] ?? match;
+  });
+  if (unresolved.length > 0) {
+    throw new Error(
+      `Unresolved variables: ${unresolved.join(", ")}. Available vars: ${Object.keys(vars).join(", ") || "(none)"}`
+    );
+  }
+  return resolved;
+}
+
+// src/builders/pipeline.ts
+var AGENT_ROLES = {
+  "po": { title: "Product Owner", description: "Scopes features into tasks with acceptance criteria. Creates and manages the task backlog." },
+  "architect": { title: "System Architect", description: "Designs architecture, data flow, and contracts. Creates Architecture Decision Records (ADRs)." },
+  "fullstack-dev": { title: "Full-Stack Developer", description: "Implements features end-to-end. Writes code, tests, and verifies quality gates." },
+  "reviewer": { title: "Code Reviewer", description: "Reviews code for correctness, security, and conventions. Returns GREEN or RED with findings." },
+  "ux-ui": { title: "UX/UI Engineer", description: "Reviews UI for accessibility, visual consistency, and user experience quality." },
+  "qa": { title: "QA Engineer", description: "Tests implementations against acceptance criteria. Reports PASS, NEEDS_IMPROVEMENT, or FAIL." },
+  "adversarial-reviewer": { title: "Adversarial Reviewer", description: "Second-pass reviewer. Hunts for missed bugs, security gaps, and edge cases." },
+  "docs-writer": { title: "Documentation Writer", description: "Maintains project context documentation. Updates docs surgically based on code changes." },
+  "memory-keeper": { title: "Memory Keeper", description: "Records session logs, decisions, and conventions. Maintains project memory across sessions." },
+  "teamlead": { title: "Team Lead", description: "Orchestrates the squad. Only agent that talks to the user. Assesses work, dispatches pipelines, synthesizes results." }
+};
+function agentRef(agent) {
+  return `@squad-${agent}`;
+}
+function agentLine(agent) {
+  const role = AGENT_ROLES[agent];
+  if (!role) return "";
+  return `- ${agentRef(agent)} \u2014 ${role.title}. ${role.description}`;
+}
+function buildPipelineForLevel(level, steps, hasParallel, description) {
+  const pipelineAgents = steps.filter((a) => a !== "teamlead");
+  if (pipelineAgents.length === 0) return "";
+  const parallelIndex = hasParallel ? pipelineAgents.findIndex(
+    (a) => a === "reviewer" || a === "ux-ui" || a === "qa"
+  ) : -1;
+  const formatted = pipelineAgents.map((a, i) => {
+    if (parallelIndex !== -1 && i >= parallelIndex && (a === "reviewer" || a === "ux-ui" || a === "qa")) {
+      return `     ${agentRef(a)} \u2016`;
+    }
+    return `  ${i + 1}. ${agentRef(a)}`;
+  });
+  let pipelineStr = formatted.join("\n");
+  if (parallelIndex !== -1) {
+    const parallelAgents = pipelineAgents.filter(
+      (a, i) => i >= parallelIndex && (a === "reviewer" || a === "ux-ui" || a === "qa")
+    );
+    const prevNames = pipelineAgents.slice(0, parallelIndex);
+    const lastBeforeParallel = prevNames.length > 0 ? `${agentRef(prevNames[prevNames.length - 1])}` : "the previous step";
+    pipelineStr += `
+
+     **Parallel:** ${parallelAgents.map((a) => agentRef(a)).join(", ")} run simultaneously after ${lastBeforeParallel}. Dispatch them in a single message.`;
+  }
+  return `### ${level}
+**When:** ${description}
+**Pipeline:**
+${pipelineStr}`;
+}
+function buildPipelineSection(agents, features) {
+  const has = (a) => agents.includes(a);
+  const lines = [];
+  lines.push("## Available Squad Agents");
+  const displayOrder = [
+    "teamlead",
+    "po",
+    "architect",
+    "fullstack-dev",
+    "reviewer",
+    "ux-ui",
+    "qa",
+    "adversarial-reviewer",
+    "docs-writer",
+    "memory-keeper"
+  ];
+  for (const agent of displayOrder) {
+    if (has(agent)) {
+      lines.push(agentLine(agent));
+    }
+  }
+  lines.push("");
+  lines.push("## Work Type Assessment");
+  lines.push("");
+  lines.push("Before dispatching, classify the work into one of five levels:");
+  lines.push("");
+  lines.push("| Level | Criteria |");
+  lines.push("|---|---|");
+  lines.push("| **TINY** | Single-line fix, typo, copy change, color token swap. Zero logic change. Zero new files. A non-technical person could verify it. |");
+  lines.push("| **SMALL** | Minor bug fix, simple new component, single new field. Changes behavior in one isolated area. No schema changes. 1-2 files. |");
+  lines.push("| **MEDIUM** | New feature, new page/route, new data model, new component family (3+ files). Creates something new or changes cross-module behavior. |");
+  lines.push("| **SECURITY-SENSITIVE** | Any change touching auth, API keys, environment variables, file upload, webhooks, user data, or permissions. This is true EVEN IF the code change is one line. |");
+  lines.push("| **MAJOR** | New service integration, architecture pattern change, breaking schema change, data migration, significant refactor. High risk, wide blast radius. |");
+  lines.push("");
+  lines.push("**Rules for classifying:**");
+  lines.push("- When unsure between two levels, pick the HIGHER one. Under-process is a production bug. Over-process is a few extra agent calls.");
+  lines.push("- If the change touches auth, security, or user data at all, it is SECURITY-SENSITIVE regardless of size.");
+  lines.push('- If the user describes it as "small" but it touches 3+ files or crosses module boundaries, escalate to MEDIUM.');
+  lines.push("- A TINY task is genuinely atomic \u2014 one line, one file, no logic change. If you hesitate, it's not TINY.");
+  lines.push("");
+  lines.push("## Pipelines by Work Type");
+  const hasTasks = features.tasks && has("po");
+  const tinyAgents = ["fullstack-dev", "reviewer"];
+  if (has("adversarial-reviewer")) tinyAgents.push("adversarial-reviewer");
+  if (has("memory-keeper")) tinyAgents.push("memory-keeper");
+  lines.push(buildPipelineForLevel(
+    "TINY",
+    tinyAgents,
+    false,
+    "Single-character or single-line fix. Typo. Copy change. Zero logic. Zero new files."
+  ));
+  lines.push("");
+  const smallAgents = [];
+  if (hasTasks && has("po")) {
+    smallAgents.push("po");
+    smallAgents.push("fullstack-dev");
+  } else {
+    smallAgents.push("fullstack-dev");
+  }
+  smallAgents.push("reviewer");
+  if (has("ux-ui")) smallAgents.push("ux-ui");
+  if (has("qa")) smallAgents.push("qa");
+  if (has("adversarial-reviewer")) smallAgents.push("adversarial-reviewer");
+  if (has("docs-writer")) smallAgents.push("docs-writer");
+  if (has("memory-keeper")) smallAgents.push("memory-keeper");
+  const smallDesc = hasTasks ? "Minor bug fix, simple component, small feature. PO scopes it, dev implements, reviewer checks." : "Minor bug fix, simple component, small feature. Dev implements, reviewer checks.";
+  lines.push(buildPipelineForLevel(
+    "SMALL",
+    smallAgents,
+    has("reviewer") && (has("ux-ui") || has("qa")),
+    smallDesc
+  ));
+  lines.push("");
+  const mediumAgents = [];
+  if (hasTasks && has("po")) {
+    mediumAgents.push("po");
+  }
+  if (has("architect")) mediumAgents.push("architect");
+  mediumAgents.push("fullstack-dev");
+  if (has("reviewer")) mediumAgents.push("reviewer");
+  if (has("ux-ui")) mediumAgents.push("ux-ui");
+  if (has("qa")) mediumAgents.push("qa");
+  if (has("adversarial-reviewer")) mediumAgents.push("adversarial-reviewer");
+  if (has("docs-writer")) mediumAgents.push("docs-writer");
+  if (has("memory-keeper")) mediumAgents.push("memory-keeper");
+  lines.push(buildPipelineForLevel(
+    "MEDIUM",
+    mediumAgents,
+    true,
+    "New feature, new page/route, new component family. Full pipeline with parallel quality gates."
+  ));
+  lines.push("");
+  lines.push(buildPipelineForLevel(
+    "SECURITY-SENSITIVE",
+    mediumAgents,
+    true,
+    "Any change touching auth, secrets, user data, file upload, or permissions. EVEN IF one line. Heightened security scrutiny on all review stages."
+  ));
+  lines.push("");
+  lines.push("     **Extra:** The reviewer and adversarial reviewer apply heightened scrutiny on all security surfaces. Adversarial reviewer must explicitly check auth bypass, data leak vectors, injection surfaces, and secret handling.");
+  lines.push("");
+  lines.push(buildPipelineForLevel(
+    "MAJOR",
+    mediumAgents,
+    true,
+    "New service integration, architecture change, breaking schema change, data migration. High risk, wide blast radius."
+  ));
+  lines.push("");
+  if (has("architect")) {
+    lines.push("     **Extra:** Architect must produce full design before any implementation. Reviewer must do architecture-level review in addition to code review. QA must test full regression.");
+  }
+  if (has("memory-keeper")) {
+    lines.push("     **Extra:** Memory Keeper must record a detailed session log with all decisions and risks.");
+  }
+  if (!hasTasks) {
+    lines.push("");
+    lines.push("## User-Driven Workflow");
+    lines.push("");
+    lines.push("This squad has no Product Owner. The user defines tasks directly. When the user gives you a well-defined task, skip the PO step and dispatch the developer directly. When the user gives a vague request, interview them to extract scope before dispatching.");
+  }
+  if (!has("memory-keeper")) {
+    lines.push("");
+    lines.push("## Memory Management");
+    lines.push("");
+    lines.push("This squad has no Memory Keeper. At the end of each session, summarize what was accomplished, decisions made, and what remains open. This summary IS the session record.");
+  }
+  return lines.join("\n");
+}
+
+// src/utils/paths.ts
+import { resolve } from "path";
+import { fileURLToPath } from "url";
+import { existsSync } from "fs";
+var __dirname2 = fileURLToPath(new URL(".", import.meta.url));
+var bundledPath = resolve(__dirname2, "..", "sections");
+var devPath = resolve(__dirname2, "..", "..", "sections");
+var SECTIONS_DIR = existsSync(bundledPath) ? bundledPath : devPath;
+
+// src/builders/agent.ts
+async function buildAgent(agent, ctx, pipelineData) {
+  const registry = getAgentSections(ctx.platform);
+  const activeSections = filterSections(registry, ctx);
+  const resolvedVars = { ...ctx.vars };
+  if (agent === "teamlead" && pipelineData) {
+    const pipelineContent = buildPipelineSection(pipelineData.agents, pipelineData.features);
+    resolvedVars["WORKFLOW_PIPELINE"] = pipelineContent;
+  }
+  const sectionContents = [];
+  for (const section of activeSections) {
+    const filePath = section.base === "platform" ? `${SECTIONS_DIR}/${ctx.platform}/${section.file}` : `${SECTIONS_DIR}/shared/${section.file}`;
+    let content = await loadTemplate(filePath);
+    content = resolveVars(content, resolvedVars);
+    sectionContents.push(content);
+  }
+  const body = buildAgentBody(sectionContents);
+  const frontmatterPath = `${SECTIONS_DIR}/shared/frontmatter/${agent}.yaml`;
+  let frontmatterYaml = await loadTemplate(frontmatterPath);
+  frontmatterYaml = resolveVars(frontmatterYaml, resolvedVars);
+  const parsed = parseYaml(frontmatterYaml);
+  const frontmatter = {
+    name: String(parsed.name ?? ""),
+    description: String(parsed.description ?? "").replace(/\n/g, " "),
+    mode: parsed.mode ?? "subagent",
+    hidden: Boolean(parsed.hidden),
+    color: String(parsed.color ?? "")
+  };
+  const fileContent = buildAgentFile(frontmatter, body);
+  const fileName = `squad-${agent}.md`;
+  return {
+    path: `.opencode/agents/${fileName}`,
+    content: fileContent
+  };
+}
+
+// src/builders/workflow.ts
+var WORKFLOW_FILES = ["state", "tasks", "memory", "context", "sessions"];
+var FEATURE_KEY = {
+  state: "state",
+  tasks: "tasks",
+  memory: "memory",
+  context: "context",
+  sessions: "sessions"
+};
+async function buildWorkflowFiles(platform, features, vars) {
+  const files = [];
+  for (const name of WORKFLOW_FILES) {
+    if (!features[FEATURE_KEY[name]]) continue;
+    const filePath = `${SECTIONS_DIR}/${platform}/workflow/${name}.md`;
+    let content = await loadTemplate(filePath);
+    content = resolveVars(content, vars);
+    files.push({
+      path: `.opencode/workflow/${name}.md`,
+      content
+    });
+  }
+  return files;
+}
+
+// src/builders/tasks.ts
+async function buildTaskFiles(vars) {
+  const templatePath = `${SECTIONS_DIR}/shared/task-template.md`;
+  let template = await loadTemplate(templatePath);
+  template = resolveVars(template, vars);
+  const task01 = template.replaceAll("task-XX", "task-01").replaceAll("# Task XX:", "# Task 01:");
+  return [
+    {
+      path: ".agent/tasks/TASK_TEMPLATE.md",
+      content: template
+    },
+    {
+      path: ".agent/tasks/task-01.md",
+      content: task01
+    }
+  ];
+}
+
+// src/builders/context.ts
+var CONTEXT_STACKS = ["nextjs", "python", "generic"];
+var CONTEXT_FILES = ["stack", "conventions", "architecture"];
+async function buildContextDocs(platform, features, stack, vars) {
+  if (!features.context) return [];
+  const files = [];
+  const relevantStacks = stack.filter((s) => CONTEXT_STACKS.includes(s));
+  if (relevantStacks.length === 0) {
+    relevantStacks.push("generic");
+  }
+  for (const tech of [...new Set(relevantStacks)]) {
+    for (const file of CONTEXT_FILES) {
+      try {
+        const filePath = `${SECTIONS_DIR}/${platform}/context/${tech}/${file}.md`;
+        let content = await loadTemplate(filePath);
+        content = resolveVars(content, vars);
+        files.push({
+          path: `.agent/context/project/${tech}-${file}.md`,
+          content
+        });
+      } catch {
+      }
+    }
+  }
+  return files;
+}
+async function buildMemoryFiles(features, vars) {
+  if (!features.memory) return [];
+  const files = [];
+  const memoryFiles = ["decisions", "conventions"];
+  if (features.sessions) {
+    memoryFiles.push("patterns");
+  }
+  for (const name of memoryFiles) {
+    const filePath = `${SECTIONS_DIR}/shared/memory/${name}.md`;
+    let content = await loadTemplate(filePath);
+    content = resolveVars(content, vars);
+    files.push({
+      path: `.agent/memory/${name}.md`,
+      content
+    });
+  }
+  return files;
+}
+
+// src/builders/config.ts
+async function buildOpenCodeJson(config, agents) {
+  const agentAllowList = agents.map((a) => `squad-${a}`);
+  const json = {
+    permissions: {
+      bash: {
+        allow: ["npm *", "pnpm *", "npx *", "git *", "node *", "python *", "tsx *"]
+      },
+      edit: {
+        deny: [".opencode/agents/*"]
+      },
+      task: {
+        allow: agentAllowList
+      },
+      external_directory: {
+        allow: ["/var/folders/**"]
+      }
+    }
+  };
+  return {
+    path: "opencode.json",
+    content: JSON.stringify(json, null, 2) + "\n"
+  };
+}
+async function buildAgentsMd(config, agents) {
+  const templatePath = `${SECTIONS_DIR}/opencode/config/agents.md`;
+  let content = await loadTemplate(templatePath);
+  const agentList = agents.map((a) => `- **squad-${a}** \u2014 ${getAgentDesc(a)}`).join("\n");
+  content = content.replace("${PROJECT_NAME}", config.projectName);
+  content = content.replace("${AGENT_LIST}", agentList);
+  return {
+    path: "AGENTS.md",
+    content
+  };
+}
+function getAgentDesc(agent) {
+  const descriptions = {
+    "fullstack-dev": "Full-Stack Developer. Implements features end-to-end.",
+    "reviewer": "Code Reviewer. GREEN/RED review of completed code.",
+    "po": "Product Owner. Creates and manages task files.",
+    "architect": "System Architect. Designs systems and architecture.",
+    "ux-ui": "UX/UI Engineer. Reviews UI against design standards.",
+    "qa": "QA Engineer. Tests implementations against acceptance criteria.",
+    "adversarial-reviewer": "Adversarial Reviewer. Second-pass bug hunting.",
+    "docs-writer": "Documentation Writer. Maintains project context docs.",
+    "memory-keeper": "Memory Keeper. Manages project memory across sessions.",
+    "teamlead": "Team Lead. Orchestrates the squad. The only agent the user talks to."
+  };
+  return descriptions[agent] ?? "";
+}
+
+// src/utils/write.ts
+import { access, mkdir, writeFile, readFile as readFile2 } from "fs/promises";
+import { dirname, relative, resolve as resolve2 } from "path";
+import pc from "picocolors";
+var promptUser = null;
+async function writeFileSafe(projectDir, filePath, content, dryRun) {
+  const absolutePath = resolve2(projectDir, filePath);
+  const relPath = relative(projectDir, absolutePath);
+  if (dryRun) {
+    console.log(pc.dim(`  [dry-run] Would write: ${relPath}`));
+    return "dry-run";
+  }
+  await mkdir(dirname(absolutePath), { recursive: true });
+  const exists = await access(absolutePath).then(() => true).catch(() => false);
+  if (exists) {
+    const existing = await readFile2(absolutePath, "utf-8");
+    if (existing === content) {
+      return "skipped";
+    }
+    if (promptUser) {
+      const overwrite = await promptUser(
+        `File ${pc.yellow(relPath)} already exists. Overwrite?`
+      );
+      if (!overwrite) return "skipped";
+    }
+    await writeFile(absolutePath, content, "utf-8");
+    return "overwritten";
+  }
+  await writeFile(absolutePath, content, "utf-8");
+  return "created";
+}
+
+// src/wizard.ts
+import { resolve as resolve3 } from "path";
+import { mkdir as mkdir2, access as access2 } from "fs/promises";
+import { execSync } from "child_process";
+async function runWizard() {
+  intro(pc2.bold(pc2.cyan("ai-squad init")));
+  const projectName = await text({
+    message: "Project name?",
+    placeholder: "my-awesome-app",
+    validate(value) {
+      if (!value) return "Required.";
+      if (!/^[a-z0-9-]+$/.test(value)) return "Lowercase letters, numbers, and hyphens only.";
+    }
+  });
+  if (isCancel(projectName)) {
+    cancel("Cancelled.");
+    process.exit(0);
+  }
+  const allTech = getTechStacks();
+  const techStack = await multiselect({
+    message: "Tech stack? (space to select, enter to confirm)",
+    options: allTech.map((t) => ({ value: t, label: t.charAt(0).toUpperCase() + t.slice(1) })),
+    required: false
+  });
+  if (isCancel(techStack)) {
+    cancel("Cancelled.");
+    process.exit(0);
+  }
+  const squadChoice = await select({
+    message: "Choose a squad:",
+    options: SQUADS.map((s2) => ({
+      value: s2.id,
+      label: s2.name,
+      hint: s2.description
+    }))
+  });
+  if (isCancel(squadChoice)) {
+    cancel("Cancelled.");
+    process.exit(0);
+  }
+  const packageLevels = [
+    { value: "minimal", label: "Minimal", hint: "Just the agents" },
+    { value: "essential", label: "Essential", hint: "+ tasks + state tracking" },
+    { value: "standard", label: "Standard", hint: "+ memory + context docs" },
+    { value: "comprehensive", label: "Comprehensive", hint: "+ sessions + full context" }
+  ];
+  const packageLevel = await select({
+    message: "Infrastructure level?",
+    options: packageLevels
+  });
+  if (isCancel(packageLevel)) {
+    cancel("Cancelled.");
+    process.exit(0);
+  }
+  const recommendedSkills = getSkillsForStack(techStack);
+  let installSkills = false;
+  if (recommendedSkills.length > 0) {
+    const result = await select({
+      message: `Install ${recommendedSkills.length} recommended skills?`,
+      options: [
+        { value: true, label: "Yes, install skills", hint: recommendedSkills.map((s2) => s2.source).join(", ") },
+        { value: false, label: "Skip for now" }
+      ]
+    });
+    if (isCancel(result)) {
+      cancel("Cancelled.");
+      process.exit(0);
+    }
+    installSkills = Boolean(result);
+  }
+  const platformChoice = PLATFORMS[0];
+  const platform = platformChoice;
+  const config = {
+    projectName,
+    platform,
+    techStack: techStack ?? [],
+    squad: squadChoice,
+    packageLevel,
+    installSkills,
+    dryRun: false
+  };
+  const features = resolveFeatures(config.packageLevel);
+  const squad = getSquad(config.squad);
+  const infraAgents = getInfraAgents(config.packageLevel);
+  const orchestratorAgents = getOrchestratorInfra(squad.agents);
+  const allAgents = [.../* @__PURE__ */ new Set([...squad.agents, ...infraAgents, ...orchestratorAgents])];
+  const skills = config.installSkills ? getSkillsForStack(config.techStack) : [];
+  const featureList = Object.entries(features).filter(([, v]) => v).map(([k]) => k).join(", ") || "none";
+  note(
+    `${pc2.bold(config.projectName)}
+Stack:    ${config.techStack.join(", ") || "none"}
+Squad:    ${squad.name} (${allAgents.map((a) => `squad-${a}`).join(", ")})
+Level:    ${config.packageLevel}
+Features: ${featureList}
+${skills.length > 0 ? `Skills:   ${skills.map((s2) => s2.source).join(", ")}
+` : ""}`,
+    "Review"
+  );
+  const confirmGen = await select({
+    message: "Generate project?",
+    options: [
+      { value: "yes", label: "Yes, generate" },
+      { value: "dry-run", label: "Dry run (preview only)" },
+      { value: "no", label: "Cancel" }
+    ]
+  });
+  if (isCancel(confirmGen) || confirmGen === "no") {
+    cancel("Cancelled.");
+    process.exit(0);
+  }
+  const dryRun = confirmGen === "dry-run";
+  const projectDir = resolve3(process.cwd(), config.projectName);
+  if (!dryRun) {
+    try {
+      await access2(projectDir);
+      console.log(pc2.yellow(`
+Directory ${config.projectName} already exists. Files will be merged.`));
+    } catch {
+      await mkdir2(projectDir, { recursive: true });
+    }
+  }
+  const s = spinner();
+  s.start("Generating agent infrastructure...");
+  try {
+    const vars = {
+      PROJECT_NAME: config.projectName
+    };
+    const files = [];
+    for (const agent of allAgents) {
+      const ctx = {
+        projectName: config.projectName,
+        platform: config.platform,
+        agent,
+        features,
+        stack: config.techStack,
+        vars: { ...vars, AGENT_NAME: `squad-${agent}` }
+      };
+      const pipelineData = agent === "teamlead" ? { agents: allAgents, features } : void 0;
+      const file = await buildAgent(agent, ctx, pipelineData);
+      files.push(file);
+    }
+    const workflowFiles = await buildWorkflowFiles(config.platform, features, vars);
+    files.push(...workflowFiles);
+    if (features.tasks) {
+      const taskFiles = await buildTaskFiles(vars);
+      files.push(...taskFiles);
+    }
+    if (features.memory) {
+      const memoryFiles = await buildMemoryFiles(features, vars);
+      files.push(...memoryFiles);
+    }
+    if (features.context) {
+      const contextFiles = await buildContextDocs(config.platform, features, config.techStack, vars);
+      files.push(...contextFiles);
+    }
+    const openCodeJson = await buildOpenCodeJson(config, allAgents);
+    files.push(openCodeJson);
+    const agentsMd = await buildAgentsMd(config, allAgents);
+    files.push(agentsMd);
+    clearCache();
+    let created = 0;
+    let skipped = 0;
+    for (const file of files) {
+      const result = await writeFileSafe(projectDir, file.path, file.content, dryRun);
+      if (result === "created" || result === "overwritten") created++;
+      if (result === "skipped") skipped++;
+    }
+    s.stop(dryRun ? "Dry run complete" : "Generation complete");
+    if (skills.length > 0 && config.installSkills) {
+      const commands = getSkillInstallCommands(skills);
+      if (dryRun) {
+        console.log(pc2.dim("\n  Skills to install:"));
+        for (const cmd of commands) {
+          console.log(pc2.dim(`  [dry-run] ${cmd}`));
+        }
+      } else {
+        console.log("");
+        for (const cmd of commands) {
+          console.log(pc2.dim(`  Installing: ${cmd.replace(" -y", "")}`));
+          try {
+            execSync(cmd, { cwd: projectDir, stdio: "pipe" });
+            console.log(pc2.green(`  \u2713 Installed`));
+          } catch {
+            console.log(pc2.yellow(`  \u26A0 Skipped \u2014 npx skills may not be available`));
+          }
+        }
+      }
+    }
+    const summary = [
+      `${pc2.green("Created:")} ${created} files`,
+      ...skipped > 0 ? [`${pc2.yellow("Skipped:")} ${skipped} files (unchanged)`] : [],
+      `${pc2.dim("Total:")}   ${files.length} files`,
+      "",
+      `${pc2.dim("Agents:")}  ${allAgents.map((a) => `squad-${a}`).join(", ")}`
+    ].join("\n");
+    outro(summary);
+    if (!dryRun) {
+      console.log(pc2.dim(`
+Next: cd ${config.projectName} && opencode`));
+    }
+  } catch (err) {
+    s.stop("Generation failed");
+    console.error(pc2.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+}
+
+// src/index.ts
+runWizard().catch((err) => {
+  console.error(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});