@qazuor/claude-code-config 0.1.0

package/dist/index.cjs

@@ -0,0 +1,3887 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// node_modules/.pnpm/tsup@8.5.1_postcss@8.5.6_typescript@5.9.3/node_modules/tsup/assets/cjs_shims.js
+var init_cjs_shims = __esm({
+  "node_modules/.pnpm/tsup@8.5.1_postcss@8.5.6_typescript@5.9.3/node_modules/tsup/assets/cjs_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/lib/utils/fs.ts
+async function pathExists(filePath) {
+  return import_fs_extra.default.pathExists(filePath);
+}
+async function isDirectory(filePath) {
+  try {
+    const stat = await import_fs_extra.default.stat(filePath);
+    return stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function readJson(filePath) {
+  return import_fs_extra.default.readJson(filePath);
+}
+async function writeJson(filePath, data, options) {
+  await import_fs_extra.default.ensureDir(import_node_path.default.dirname(filePath));
+  await import_fs_extra.default.writeJson(filePath, data, { spaces: options?.spaces ?? 2 });
+}
+async function readFile(filePath) {
+  return import_fs_extra.default.readFile(filePath, "utf-8");
+}
+async function writeFile(filePath, content) {
+  await import_fs_extra.default.ensureDir(import_node_path.default.dirname(filePath));
+  await import_fs_extra.default.writeFile(filePath, content, "utf-8");
+}
+async function copy(src, dest, options) {
+  await import_fs_extra.default.ensureDir(import_node_path.default.dirname(dest));
+  await import_fs_extra.default.copy(src, dest, { overwrite: options?.overwrite ?? false });
+}
+async function ensureDir(dirPath) {
+  await import_fs_extra.default.ensureDir(dirPath);
+}
+async function listFiles(pattern, options) {
+  return (0, import_glob.glob)(pattern, {
+    cwd: options?.cwd,
+    ignore: options?.ignore,
+    nodir: true
+  });
+}
+async function listDirs(pattern, options) {
+  const matches = await (0, import_glob.glob)(pattern, {
+    cwd: options?.cwd
+  });
+  const dirs = [];
+  for (const match of matches) {
+    const fullPath = options?.cwd ? import_node_path.default.join(options.cwd, match) : match;
+    if (await isDirectory(fullPath)) {
+      dirs.push(match);
+    }
+  }
+  return dirs;
+}
+function joinPath(...segments) {
+  return import_node_path.default.join(...segments);
+}
+function dirname(filePath) {
+  return import_node_path.default.dirname(filePath);
+}
+async function backup(src, suffix = ".backup") {
+  const backupPath = `${src}${suffix}`;
+  await copy(src, backupPath, { overwrite: true });
+  return backupPath;
+}
+var import_node_path, import_fs_extra, import_glob;
+var init_fs = __esm({
+  "src/lib/utils/fs.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node_path = __toESM(require("path"), 1);
+    import_fs_extra = __toESM(require("fs-extra"), 1);
+    import_glob = require("glob");
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  BUNDLES: () => BUNDLES,
+  DEPENDENCIES: () => DEPENDENCIES,
+  MCP_SERVERS: () => MCP_SERVERS,
+  PERMISSION_PRESETS: () => PERMISSION_PRESETS,
+  PLACEHOLDERS: () => PLACEHOLDERS,
+  buildTemplateContext: () => buildTemplateContext,
+  createDefaultConfig: () => createDefaultConfig,
+  detectProject: () => detectProject,
+  getAllBundles: () => getAllBundles,
+  getBundleById: () => getBundleById,
+  hasConfig: () => hasConfig,
+  installModules: () => installModules,
+  loadRegistry: () => loadRegistry,
+  mergeBundleSelection: () => mergeBundleSelection,
+  processTemplates: () => processTemplates,
+  readConfig: () => readConfig,
+  replacePlaceholders: () => replacePlaceholders,
+  resolveBundle: () => resolveBundle,
+  resolveBundles: () => resolveBundles,
+  resolveModules: () => resolveModules,
+  writeConfig: () => writeConfig
+});
+module.exports = __toCommonJS(src_exports);
+init_cjs_shims();
+
+// src/constants/bundles.ts
+init_cjs_shims();
+var BUNDLES = [
+  // ===================
+  // STACK BUNDLES
+  // ===================
+  {
+    id: "react-tanstack-stack",
+    name: "React + TanStack Stack",
+    description: "React with TanStack Router/Start for admin dashboards and SPAs",
+    category: "stack",
+    longDescription: "Complete stack for building React applications with TanStack Router and Start. Includes React component development, TanStack-specific patterns, and related testing/quality tools.",
+    techStack: ["React", "TanStack Start", "TanStack Router", "TanStack Query", "TypeScript"],
+    tags: ["react", "tanstack", "admin", "spa"],
+    complexity: "comprehensive",
+    responsibilities: [
+      "React component architecture and best practices",
+      "TanStack Router file-based routing patterns",
+      "Server state management with TanStack Query",
+      "Form handling with React Hook Form + Zod",
+      "UI components with Shadcn/Radix primitives"
+    ],
+    scope: "Full frontend stack for React SPAs and admin dashboards",
+    useCases: [
+      "Admin dashboards and internal tools",
+      "Complex single-page applications",
+      "Data-heavy applications with tables/forms",
+      "Projects using TanStack ecosystem"
+    ],
+    moduleDetails: {
+      agents: [
+        {
+          id: "react-senior-dev",
+          role: "React Architecture",
+          responsibilities: ["Component design", "State management", "Performance optimization"]
+        },
+        {
+          id: "tanstack-start-engineer",
+          role: "TanStack Specialist",
+          responsibilities: ["Router setup", "Query patterns", "SSR configuration"]
+        },
+        {
+          id: "ux-ui-designer",
+          role: "UI/UX Design",
+          responsibilities: ["Component styling", "Accessibility", "Design system"]
+        }
+      ],
+      skills: [
+        { id: "web-app-testing", purpose: "React Testing Library patterns" },
+        { id: "shadcn-specialist", purpose: "Shadcn UI component usage" },
+        { id: "accessibility-audit", purpose: "WCAG compliance" },
+        { id: "tanstack-query-patterns", purpose: "Query/mutation patterns" },
+        { id: "react-hook-form-patterns", purpose: "Form validation patterns" },
+        { id: "zustand-patterns", purpose: "Client state management" }
+      ],
+      commands: [],
+      docs: [{ id: "design-standards", topic: "UI/UX design standards" }]
+    },
+    modules: [
+      { id: "react-senior-dev", category: "agents" },
+      { id: "tanstack-start-engineer", category: "agents" },
+      { id: "ux-ui-designer", category: "agents" },
+      { id: "web-app-testing", category: "skills" },
+      { id: "shadcn-specialist", category: "skills" },
+      { id: "accessibility-audit", category: "skills" },
+      { id: "tanstack-query-patterns", category: "skills" },
+      { id: "react-hook-form-patterns", category: "skills" },
+      { id: "zustand-patterns", category: "skills", optional: true },
+      { id: "design-standards", category: "docs", requiredBy: ["ux-ui-designer"], optional: true }
+    ]
+  },
+  {
+    id: "astro-react-stack",
+    name: "Astro + React Stack",
+    description: "Astro with React islands for content-focused websites",
+    category: "stack",
+    longDescription: "Stack for building fast, content-focused websites with Astro and React components. Perfect for marketing sites, blogs, and documentation sites.",
+    techStack: ["Astro", "React", "Tailwind CSS", "MDX", "TypeScript"],
+    tags: ["astro", "react", "ssg", "content"],
+    complexity: "standard",
+    responsibilities: [
+      "Static site generation with Astro",
+      "Interactive React islands for dynamic content",
+      "SEO optimization and meta tags",
+      "Performance-first architecture",
+      "Content management with MDX"
+    ],
+    scope: "Content-focused websites with selective interactivity",
+    useCases: [
+      "Marketing and landing pages",
+      "Documentation sites",
+      "Blogs and content platforms",
+      "Portfolio websites"
+    ],
+    moduleDetails: {
+      agents: [
+        {
+          id: "astro-engineer",
+          role: "Astro Specialist",
+          responsibilities: ["Routing", "Islands architecture", "Build optimization"]
+        },
+        {
+          id: "react-senior-dev",
+          role: "React Components",
+          responsibilities: ["Interactive components", "Client hydration"]
+        },
+        {
+          id: "seo-ai-specialist",
+          role: "SEO Optimization",
+          responsibilities: ["Meta tags", "Structured data", "Performance"]
+        }
+      ],
+      skills: [
+        { id: "web-app-testing", purpose: "Component testing" },
+        { id: "vercel-specialist", purpose: "Deployment optimization" },
+        { id: "performance-audit", purpose: "Core Web Vitals" }
+      ],
+      commands: [],
+      docs: []
+    },
+    modules: [
+      { id: "astro-engineer", category: "agents" },
+      { id: "react-senior-dev", category: "agents" },
+      { id: "seo-ai-specialist", category: "agents" },
+      { id: "web-app-testing", category: "skills" },
+      { id: "vercel-specialist", category: "skills" },
+      { id: "performance-audit", category: "skills" }
+    ]
+  },
+  {
+    id: "nextjs-prisma-stack",
+    name: "Next.js + Prisma Stack",
+    description: "Full-stack Next.js with Prisma for modern web apps",
+    category: "stack",
+    longDescription: "Complete full-stack setup with Next.js App Router and Prisma ORM. Includes React components, Server Actions, and database patterns.",
+    techStack: ["Next.js", "React", "Prisma", "Tailwind CSS", "TypeScript"],
+    tags: ["nextjs", "prisma", "fullstack", "react"],
+    complexity: "comprehensive",
+    alternativeTo: ["react-tanstack-stack", "astro-react-stack"],
+    responsibilities: [
+      "Full-stack React with Next.js App Router",
+      "Database modeling with Prisma ORM",
+      "Server Actions and API routes",
+      "Authentication with NextAuth.js",
+      "Deployment on Vercel"
+    ],
+    scope: "Complete full-stack web application development",
+    useCases: [
+      "SaaS applications",
+      "E-commerce platforms",
+      "Full-stack web apps with auth",
+      "Projects needing SSR/SSG flexibility"
+    ],
+    moduleDetails: {
+      agents: [
+        {
+          id: "nextjs-engineer",
+          role: "Next.js Specialist",
+          responsibilities: ["App Router", "Server Actions", "Caching strategies"]
+        },
+        {
+          id: "react-senior-dev",
+          role: "React Components",
+          responsibilities: ["Client components", "State management"]
+        },
+        {
+          id: "prisma-engineer",
+          role: "Database",
+          responsibilities: ["Schema design", "Migrations", "Query optimization"]
+        },
+        {
+          id: "ux-ui-designer",
+          role: "UI/UX",
+          responsibilities: ["Design system", "Responsive design"]
+        }
+      ],
+      skills: [
+        { id: "web-app-testing", purpose: "Next.js testing patterns" },
+        { id: "shadcn-specialist", purpose: "UI components" },
+        { id: "vercel-specialist", purpose: "Deployment" },
+        { id: "tanstack-query-patterns", purpose: "Client data fetching" },
+        { id: "react-hook-form-patterns", purpose: "Form handling" },
+        { id: "nextauth-patterns", purpose: "Authentication" }
+      ],
+      commands: [],
+      docs: []
+    },
+    modules: [
+      { id: "nextjs-engineer", category: "agents" },
+      { id: "react-senior-dev", category: "agents" },
+      { id: "prisma-engineer", category: "agents" },
+      { id: "ux-ui-designer", category: "agents" },
+      { id: "web-app-testing", category: "skills" },
+      { id: "shadcn-specialist", category: "skills" },
+      { id: "vercel-specialist", category: "skills" },
+      { id: "tanstack-query-patterns", category: "skills" },
+      { id: "react-hook-form-patterns", category: "skills" },
+      { id: "nextauth-patterns", category: "skills", optional: true }
+    ]
+  },
+  {
+    id: "express-prisma-stack",
+    name: "Express + Prisma API Stack",
+    description: "Express backend with Prisma ORM",
+    category: "stack",
+    longDescription: "Backend stack using Express for APIs and Prisma for database access. Classic, well-documented stack for traditional REST APIs.",
+    techStack: ["Express.js", "Prisma", "PostgreSQL", "Zod", "TypeScript"],
+    tags: ["express", "prisma", "api", "backend"],
+    complexity: "standard",
+    alternativeTo: ["hono-drizzle-stack"],
+    responsibilities: [
+      "RESTful API design with Express",
+      "Database access with Prisma ORM",
+      "Request validation with Zod",
+      "Error handling and logging",
+      "Authentication middleware"
+    ],
+    scope: "Backend API development with traditional Express patterns",
+    useCases: [
+      "REST APIs for mobile apps",
+      "Backend services for SPAs",
+      "Microservices",
+      "Projects needing Express ecosystem"
+    ],
+    moduleDetails: {
+      agents: [
+        {
+          id: "express-engineer",
+          role: "Express Specialist",
+          responsibilities: ["Route design", "Middleware", "Error handling"]
+        },
+        {
+          id: "prisma-engineer",
+          role: "Database",
+          responsibilities: ["Schema", "Migrations", "Queries"]
+        },
+        {
+          id: "node-typescript-engineer",
+          role: "Node.js/TypeScript",
+          responsibilities: ["Type safety", "Build config", "Shared packages"]
+        }
+      ],
+      skills: [
+        { id: "api-app-testing", purpose: "API testing with supertest" },
+        { id: "error-handling-patterns", purpose: "Error middleware" },
+        { id: "security-testing", purpose: "Security best practices" }
+      ],
+      commands: [],
+      docs: [{ id: "architecture-patterns", topic: "API architecture patterns" }]
+    },
+    modules: [
+      { id: "express-engineer", category: "agents" },
+      { id: "prisma-engineer", category: "agents" },
+      { id: "node-typescript-engineer", category: "agents" },
+      { id: "api-app-testing", category: "skills" },
+      { id: "error-handling-patterns", category: "skills" },
+      { id: "security-testing", category: "skills" },
+      { id: "architecture-patterns", category: "docs", optional: true }
+    ]
+  },
+  {
+    id: "hono-drizzle-stack",
+    name: "Hono + Drizzle API Stack",
+    description: "Hono API framework with Drizzle ORM for type-safe backends",
+    category: "stack",
+    longDescription: "Complete backend stack using Hono for APIs and Drizzle for database access. Includes shared TypeScript packages, API testing, and quality tools.",
+    techStack: ["Hono", "Drizzle ORM", "PostgreSQL", "Zod", "TypeScript"],
+    tags: ["hono", "drizzle", "api", "backend"],
+    complexity: "standard",
+    alternativeTo: ["express-prisma-stack"],
+    responsibilities: [
+      "High-performance APIs with Hono",
+      "Type-safe database queries with Drizzle",
+      "Schema validation with Zod",
+      "Edge-ready deployment",
+      "Monorepo-friendly architecture"
+    ],
+    scope: "Modern, type-safe backend API development",
+    useCases: [
+      "Edge/serverless APIs",
+      "Type-safe monorepo backends",
+      "High-performance REST APIs",
+      "Projects prioritizing type safety"
+    ],
+    moduleDetails: {
+      agents: [
+        {
+          id: "hono-engineer",
+          role: "Hono Specialist",
+          responsibilities: ["Route handlers", "Middleware", "OpenAPI integration"]
+        },
+        {
+          id: "db-drizzle-engineer",
+          role: "Drizzle Database",
+          responsibilities: ["Schema design", "Migrations", "Type-safe queries"]
+        },
+        {
+          id: "node-typescript-engineer",
+          role: "TypeScript/Node",
+          responsibilities: ["Type inference", "Build setup", "Shared types"]
+        }
+      ],
+      skills: [
+        { id: "api-app-testing", purpose: "Hono testing patterns" },
+        { id: "error-handling-patterns", purpose: "Error middleware" },
+        { id: "security-testing", purpose: "Security validation" }
+      ],
+      commands: [],
+      docs: [{ id: "architecture-patterns", topic: "API architecture patterns" }]
+    },
+    modules: [
+      { id: "hono-engineer", category: "agents" },
+      { id: "db-drizzle-engineer", category: "agents" },
+      { id: "node-typescript-engineer", category: "agents" },
+      { id: "api-app-testing", category: "skills" },
+      { id: "error-handling-patterns", category: "skills" },
+      { id: "security-testing", category: "skills" },
+      { id: "architecture-patterns", category: "docs", optional: true }
+    ]
+  },
+  // ===================
+  // TESTING BUNDLES
+  // ===================
+  {
+    id: "testing-complete",
+    name: "Complete Testing Suite",
+    description: "All testing skills and QA tools for comprehensive test coverage",
+    category: "testing",
+    longDescription: "Everything you need for a robust testing strategy including TDD methodology, web testing, API testing, performance testing, and QA validation.",
+    techStack: ["Vitest", "Playwright", "Testing Library", "MSW"],
+    tags: ["testing", "tdd", "qa", "e2e"],
+    complexity: "comprehensive",
+    responsibilities: [
+      "TDD workflow enforcement (Red-Green-Refactor)",
+      "Unit, integration, and E2E testing patterns",
+      "API testing with mocking and fixtures",
+      "Performance testing and benchmarking",
+      "QA validation and acceptance criteria"
+    ],
+    scope: "Complete testing strategy from unit tests to E2E",
+    useCases: [
+      "Projects requiring 90%+ test coverage",
+      "TDD-first development workflow",
+      "API-heavy applications needing thorough testing",
+      "Projects with QA validation requirements"
+    ],
+    moduleDetails: {
+      agents: [
+        {
+          id: "qa-engineer",
+          role: "Quality Assurance",
+          responsibilities: [
+            "Test planning and strategy",
+            "Acceptance criteria validation",
+            "Bug triage and reporting"
+          ]
+        }
+      ],
+      skills: [
+        { id: "tdd-methodology", purpose: "TDD workflow and best practices" },
+        { id: "web-app-testing", purpose: "Frontend testing patterns" },
+        { id: "api-app-testing", purpose: "API and backend testing" },
+        { id: "performance-testing", purpose: "Performance benchmarks" },
+        { id: "qa-criteria-validator", purpose: "Acceptance validation" }
+      ],
+      commands: [{ id: "run-tests", usage: "/run-tests --coverage" }],
+      docs: [{ id: "testing-standards", topic: "Testing conventions and standards" }]
+    },
+    modules: [
+      { id: "qa-engineer", category: "agents" },
+      { id: "tdd-methodology", category: "skills" },
+      { id: "web-app-testing", category: "skills" },
+      { id: "api-app-testing", category: "skills" },
+      { id: "performance-testing", category: "skills" },
+      { id: "qa-criteria-validator", category: "skills" },
+      { id: "run-tests", category: "commands" },
+      // Doc required by QA agent and TDD skill
+      { id: "testing-standards", category: "docs", requiredBy: ["qa-engineer", "tdd-methodology"] }
+    ]
+  },
+  {
+    id: "testing-minimal",
+    name: "Minimal Testing",
+    description: "Essential testing tools for TDD workflow",
+    category: "testing",
+    longDescription: "Core testing tools for TDD development without the full QA suite.",
+    techStack: ["Vitest", "Testing Library"],
+    tags: ["testing", "tdd", "minimal"],
+    complexity: "minimal",
+    responsibilities: [
+      "Basic TDD workflow support",
+      "Unit and integration testing",
+      "Test execution and reporting"
+    ],
+    scope: "Essential testing for small to medium projects",
+    useCases: [
+      "Small projects with basic testing needs",
+      "Quick prototypes needing some test coverage",
+      "Projects where full QA suite is overkill"
+    ],
+    moduleDetails: {
+      agents: [],
+      skills: [
+        { id: "tdd-methodology", purpose: "TDD workflow basics" },
+        { id: "api-app-testing", purpose: "API testing patterns" }
+      ],
+      commands: [{ id: "run-tests", usage: "/run-tests" }],
+      docs: []
+    },
+    modules: [
+      { id: "tdd-methodology", category: "skills" },
+      { id: "api-app-testing", category: "skills" },
+      { id: "run-tests", category: "commands" }
+    ]
+  },
+  // ===================
+  // QUALITY BUNDLES
+  // ===================
+  {
+    id: "quality-complete",
+    name: "Complete Quality Suite",
+    description: "Full quality assurance with security, performance, and accessibility audits",
+    category: "quality",
+    longDescription: "Comprehensive quality assurance bundle including all audit types, code review, and debugging tools.",
+    tags: ["quality", "audit", "security", "performance"],
+    complexity: "comprehensive",
+    responsibilities: [
+      "Security vulnerability detection and prevention",
+      "Performance profiling and optimization guidance",
+      "Accessibility compliance (WCAG) validation",
+      "Code quality review and best practices",
+      "Bug investigation and debugging assistance"
+    ],
+    scope: "Complete quality assurance across security, performance, and accessibility",
+    useCases: [
+      "Enterprise applications with strict security requirements",
+      "Public-facing apps needing accessibility compliance",
+      "Performance-critical applications",
+      "Projects requiring comprehensive code reviews"
+    ],
+    moduleDetails: {
+      agents: [
+        {
+          id: "qa-engineer",
+          role: "Quality Assurance Lead",
+          responsibilities: [
+            "Test strategy and coverage",
+            "Acceptance criteria validation",
+            "Quality metrics tracking"
+          ]
+        },
+        {
+          id: "debugger",
+          role: "Debug Specialist",
+          responsibilities: ["Root cause analysis", "Bug reproduction", "Fix verification"]
+        }
+      ],
+      skills: [
+        { id: "security-audit", purpose: "OWASP vulnerability scanning" },
+        { id: "security-testing", purpose: "Security test patterns" },
+        { id: "performance-audit", purpose: "Performance bottleneck detection" },
+        { id: "performance-testing", purpose: "Load and stress testing" },
+        { id: "accessibility-audit", purpose: "WCAG compliance checking" },
+        { id: "qa-criteria-validator", purpose: "Acceptance criteria validation" }
+      ],
+      commands: [
+        { id: "quality-check", usage: "/quality-check" },
+        { id: "code-check", usage: "/code-check src/" },
+        { id: "review-code", usage: "/review-code --thorough" },
+        { id: "review-security", usage: "/review-security" },
+        { id: "review-performance", usage: "/review-performance" }
+      ],
+      docs: [
+        { id: "code-standards", topic: "Code quality standards" },
+        { id: "atomic-commits", topic: "Atomic commit practices" }
+      ]
+    },
+    modules: [
+      { id: "qa-engineer", category: "agents" },
+      { id: "debugger", category: "agents" },
+      { id: "security-audit", category: "skills" },
+      { id: "security-testing", category: "skills" },
+      { id: "performance-audit", category: "skills" },
+      { id: "performance-testing", category: "skills" },
+      { id: "accessibility-audit", category: "skills" },
+      { id: "qa-criteria-validator", category: "skills" },
+      { id: "quality-check", category: "commands" },
+      { id: "code-check", category: "commands" },
+      { id: "review-code", category: "commands" },
+      { id: "review-security", category: "commands" },
+      { id: "review-performance", category: "commands" },
+      // Docs required by agents
+      { id: "code-standards", category: "docs", requiredBy: ["qa-engineer"] },
+      { id: "atomic-commits", category: "docs", optional: true }
+    ]
+  },
+  {
+    id: "quality-minimal",
+    name: "Minimal Quality",
+    description: "Essential quality checks for everyday development",
+    category: "quality",
+    longDescription: "Core quality tools without the full audit suite.",
+    tags: ["quality", "minimal"],
+    complexity: "minimal",
+    responsibilities: [
+      "Basic code quality checks",
+      "Quick code reviews",
+      "Lint and format validation"
+    ],
+    scope: "Essential quality checks for day-to-day development",
+    useCases: [
+      "Small projects with basic quality needs",
+      "Quick PRs needing fast review",
+      "Projects where full audits are overkill"
+    ],
+    moduleDetails: {
+      agents: [],
+      skills: [],
+      commands: [
+        { id: "quality-check", usage: "/quality-check" },
+        { id: "code-check", usage: "/code-check" },
+        { id: "review-code", usage: "/review-code" }
+      ],
+      docs: []
+    },
+    modules: [
+      { id: "quality-check", category: "commands" },
+      { id: "code-check", category: "commands" },
+      { id: "review-code", category: "commands" }
+    ]
+  },
+  // ===================
+  // DATABASE BUNDLES
+  // ===================
+  {
+    id: "drizzle-database",
+    name: "Drizzle Database",
+    description: "Drizzle ORM with type-safe database patterns",
+    category: "database",
+    longDescription: "Database development with Drizzle ORM including schema design, migrations, and data validation.",
+    techStack: ["Drizzle ORM", "PostgreSQL", "SQLite", "Zod"],
+    tags: ["database", "drizzle", "orm"],
+    alternativeTo: ["prisma-database", "mongoose-database"],
+    modules: [
+      { id: "db-drizzle-engineer", category: "agents" },
+      { id: "json-data-auditor", category: "skills" }
+    ]
+  },
+  {
+    id: "prisma-database",
+    name: "Prisma Database",
+    description: "Prisma ORM with type-safe database patterns",
+    category: "database",
+    longDescription: "Database development with Prisma ORM including schema design, migrations, and data validation.",
+    techStack: ["Prisma", "PostgreSQL", "MySQL", "SQLite", "MongoDB"],
+    tags: ["database", "prisma", "orm"],
+    alternativeTo: ["drizzle-database", "mongoose-database"],
+    modules: [
+      { id: "prisma-engineer", category: "agents" },
+      { id: "json-data-auditor", category: "skills" }
+    ]
+  },
+  {
+    id: "mongoose-database",
+    name: "MongoDB + Mongoose",
+    description: "MongoDB with Mongoose ODM",
+    category: "database",
+    longDescription: "MongoDB development with Mongoose ODM including document schemas and aggregation pipelines.",
+    techStack: ["Mongoose", "MongoDB", "TypeScript"],
+    tags: ["database", "mongodb", "mongoose", "nosql"],
+    alternativeTo: ["drizzle-database", "prisma-database"],
+    modules: [
+      { id: "mongoose-engineer", category: "agents" },
+      { id: "json-data-auditor", category: "skills" }
+    ]
+  },
+  // ===================
+  // API BUNDLES
+  // ===================
+  {
+    id: "hono-api",
+    name: "Hono API",
+    description: "Hono framework for high-performance APIs",
+    category: "api",
+    longDescription: "API development with Hono framework including middleware, validation, and error handling.",
+    techStack: ["Hono", "Zod", "TypeScript"],
+    tags: ["api", "hono", "backend"],
+    alternativeTo: ["express-api", "fastify-api", "nestjs-api"],
+    modules: [
+      { id: "hono-engineer", category: "agents" },
+      { id: "api-app-testing", category: "skills" },
+      { id: "error-handling-patterns", category: "skills" }
+    ]
+  },
+  {
+    id: "express-api",
+    name: "Express API",
+    description: "Express.js framework for REST APIs",
+    category: "api",
+    longDescription: "API development with Express.js including middleware chains, validation, and error handling.",
+    techStack: ["Express.js", "Zod", "TypeScript", "Passport.js"],
+    tags: ["api", "express", "backend"],
+    alternativeTo: ["hono-api", "fastify-api", "nestjs-api"],
+    modules: [
+      { id: "express-engineer", category: "agents" },
+      { id: "api-app-testing", category: "skills" },
+      { id: "error-handling-patterns", category: "skills" }
+    ]
+  },
+  {
+    id: "fastify-api",
+    name: "Fastify API",
+    description: "Fastify framework for high-performance APIs",
+    category: "api",
+    longDescription: "High-performance API development with Fastify plugin architecture and schema validation.",
+    techStack: ["Fastify", "TypeBox", "TypeScript", "Pino"],
+    tags: ["api", "fastify", "backend", "performance"],
+    alternativeTo: ["hono-api", "express-api", "nestjs-api"],
+    modules: [
+      { id: "fastify-engineer", category: "agents" },
+      { id: "api-app-testing", category: "skills" },
+      { id: "error-handling-patterns", category: "skills" }
+    ]
+  },
+  {
+    id: "nestjs-api",
+    name: "NestJS API",
+    description: "NestJS framework for enterprise APIs",
+    category: "api",
+    longDescription: "Enterprise API development with NestJS dependency injection and modular architecture.",
+    techStack: ["NestJS", "TypeScript", "class-validator", "TypeORM"],
+    tags: ["api", "nestjs", "backend", "enterprise"],
+    alternativeTo: ["hono-api", "express-api", "fastify-api"],
+    modules: [
+      { id: "nestjs-engineer", category: "agents" },
+      { id: "api-app-testing", category: "skills" },
+      { id: "error-handling-patterns", category: "skills" }
+    ]
+  },
+  // ===================
+  // FRONTEND BUNDLES
+  // ===================
+  {
+    id: "react-ui",
+    name: "React UI Development",
+    description: "React component development with Shadcn UI",
+    category: "frontend",
+    longDescription: "React component development bundle with Shadcn UI, accessibility, and design system tools.",
+    techStack: ["React", "Shadcn UI", "Tailwind CSS", "Radix UI"],
+    tags: ["react", "ui", "components"],
+    modules: [
+      { id: "react-senior-dev", category: "agents" },
+      { id: "ux-ui-designer", category: "agents" },
+      { id: "shadcn-specialist", category: "skills" },
+      { id: "brand-guidelines", category: "skills" },
+      { id: "accessibility-audit", category: "skills" }
+    ]
+  },
+  {
+    id: "react-forms",
+    name: "React Forms",
+    description: "React Hook Form with Zod validation",
+    category: "frontend",
+    longDescription: "Form handling patterns with React Hook Form and Zod validation. Includes Shadcn form integration.",
+    techStack: ["React Hook Form", "Zod", "React", "TypeScript"],
+    tags: ["react", "forms", "validation"],
+    modules: [
+      { id: "react-senior-dev", category: "agents" },
+      { id: "react-hook-form-patterns", category: "skills" },
+      { id: "shadcn-specialist", category: "skills" }
+    ]
+  },
+  {
+    id: "react-state-zustand",
+    name: "React State (Zustand)",
+    description: "Zustand for lightweight state management",
+    category: "frontend",
+    longDescription: "State management with Zustand including slices, persist middleware, and TanStack Query integration.",
+    techStack: ["Zustand", "TanStack Query", "React", "TypeScript"],
+    tags: ["react", "state", "zustand"],
+    alternativeTo: ["react-state-redux"],
+    modules: [
+      { id: "react-senior-dev", category: "agents" },
+      { id: "zustand-patterns", category: "skills" },
+      { id: "tanstack-query-patterns", category: "skills" }
+    ]
+  },
+  {
+    id: "react-state-redux",
+    name: "React State (Redux)",
+    description: "Redux Toolkit for complex state management",
+    category: "frontend",
+    longDescription: "State management with Redux Toolkit including RTK Query, async thunks, and enterprise patterns.",
+    techStack: ["Redux Toolkit", "RTK Query", "React", "TypeScript"],
+    tags: ["react", "state", "redux"],
+    alternativeTo: ["react-state-zustand"],
+    modules: [
+      { id: "react-senior-dev", category: "agents" },
+      { id: "redux-toolkit-patterns", category: "skills" },
+      { id: "tanstack-query-patterns", category: "skills", optional: true }
+    ]
+  },
+  {
+    id: "nextjs-auth",
+    name: "Next.js Authentication",
+    description: "NextAuth.js authentication for Next.js apps",
+    category: "frontend",
+    longDescription: "Authentication patterns with NextAuth.js including OAuth providers, credentials, sessions, and RBAC.",
+    techStack: ["NextAuth.js", "Auth.js", "Next.js", "Prisma"],
+    tags: ["nextjs", "auth", "oauth"],
+    modules: [
+      { id: "nextjs-engineer", category: "agents" },
+      { id: "nextauth-patterns", category: "skills" },
+      { id: "security-testing", category: "skills" }
+    ]
+  },
+  {
+    id: "nextjs-i18n",
+    name: "Next.js Internationalization",
+    description: "Multi-language support for Next.js apps",
+    category: "frontend",
+    longDescription: "Internationalization with next-intl including locale routing, translations, and formatting.",
+    techStack: ["next-intl", "Next.js", "React", "TypeScript"],
+    tags: ["nextjs", "i18n", "internationalization"],
+    modules: [
+      { id: "nextjs-engineer", category: "agents" },
+      { id: "i18n-specialist", category: "agents", optional: true },
+      { id: "i18n-patterns", category: "skills" }
+    ]
+  },
+  // ===================
+  // WORKFLOW BUNDLES
+  // ===================
+  {
+    id: "planning-complete",
+    name: "Complete Planning Workflow",
+    description: "Full planning workflow with PDR, tech analysis, and task tracking",
+    category: "workflow",
+    longDescription: "Complete planning workflow bundle including product definition, technical analysis, task breakdown, and sync to issue trackers.",
+    tags: ["planning", "workflow", "pdr"],
+    complexity: "comprehensive",
+    responsibilities: [
+      "Feature planning from requirements to implementation tasks",
+      "Technical analysis and architecture decision documentation",
+      "Task breakdown with atomic task methodology",
+      "Integration with issue trackers (GitHub, Linear)"
+    ],
+    scope: "End-to-end planning workflow for features, refactors, and epics",
+    useCases: [
+      "Starting a new feature from scratch",
+      "Planning a major refactor or migration",
+      "Breaking down epics into manageable tasks",
+      "Documenting technical decisions (ADRs)"
+    ],
+    moduleDetails: {
+      agents: [
+        {
+          id: "product-functional",
+          role: "Product Requirements",
+          responsibilities: [
+            "Create PDR documents",
+            "Define acceptance criteria",
+            "User story mapping"
+          ]
+        },
+        {
+          id: "product-technical",
+          role: "Technical Analysis",
+          responsibilities: ["Architecture decisions", "Tech stack evaluation", "Risk assessment"]
+        },
+        {
+          id: "tech-lead",
+          role: "Coordination & Task Breakdown",
+          responsibilities: ["Task atomization", "Workflow selection", "Team coordination"]
+        }
+      ],
+      skills: [],
+      commands: [
+        { id: "start-feature-plan", usage: '/start-feature-plan "User authentication"' },
+        { id: "start-refactor-plan", usage: '/start-refactor-plan "Database optimization"' },
+        { id: "sync-planning", usage: "/sync-planning" }
+      ],
+      docs: [
+        { id: "decision-tree", topic: "Workflow selection guide" },
+        { id: "phase-1-planning", topic: "Planning phase methodology" },
+        { id: "phase-2-implementation", topic: "Implementation phase guide" },
+        { id: "phase-3-validation", topic: "Validation and QA phase" },
+        { id: "phase-4-finalization", topic: "Closing and documentation" },
+        { id: "pdr-template", topic: "Product Definition Record template" },
+        { id: "tech-analysis-template", topic: "Technical analysis template" },
+        { id: "todos-template", topic: "Task tracking template" }
+      ]
+    },
+    modules: [
+      { id: "product-functional", category: "agents" },
+      { id: "product-technical", category: "agents" },
+      { id: "tech-lead", category: "agents" },
+      { id: "start-feature-plan", category: "commands" },
+      { id: "start-refactor-plan", category: "commands" },
+      { id: "sync-planning", category: "commands" },
+      // Required docs - needed for agents to work properly
+      { id: "decision-tree", category: "docs", requiredBy: ["tech-lead"] },
+      {
+        id: "phase-1-planning",
+        category: "docs",
+        requiredBy: ["product-functional", "product-technical"]
+      },
+      { id: "phase-2-implementation", category: "docs", requiredBy: ["tech-lead"] },
+      { id: "phase-3-validation", category: "docs" },
+      { id: "phase-4-finalization", category: "docs" },
+      { id: "pdr-template", category: "docs", requiredBy: ["product-functional"] },
+      { id: "tech-analysis-template", category: "docs", requiredBy: ["product-technical"] },
+      { id: "todos-template", category: "docs", requiredBy: ["tech-lead"] }
+    ]
+  },
+  {
+    id: "documentation-complete",
+    name: "Complete Documentation",
+    description: "All documentation standards, templates, and writing tools",
+    category: "workflow",
+    longDescription: "Everything for comprehensive documentation including standards, templates, diagrams, and writing guidelines.",
+    tags: ["documentation", "writing", "standards"],
+    complexity: "standard",
+    responsibilities: [
+      "Technical documentation writing",
+      "API documentation generation",
+      "Architecture diagram creation",
+      "Markdown formatting and standards",
+      "Glossary and terminology management"
+    ],
+    scope: "Complete documentation workflow for technical projects",
+    useCases: [
+      "Creating and maintaining project documentation",
+      "Writing API and SDK documentation",
+      "Creating architecture diagrams",
+      "Standardizing documentation across team"
+    ],
+    moduleDetails: {
+      agents: [
+        {
+          id: "tech-writer",
+          role: "Technical Writer",
+          responsibilities: ["Documentation structure", "Content writing", "Style consistency"]
+        }
+      ],
+      skills: [
+        { id: "documentation-writer", purpose: "Documentation best practices" },
+        { id: "mermaid-diagram-specialist", purpose: "Diagram creation" }
+      ],
+      commands: [
+        { id: "update-docs", usage: "/update-docs" },
+        { id: "markdown-format", usage: "/markdown-format" }
+      ],
+      docs: [
+        { id: "documentation-standards", topic: "Documentation conventions" },
+        { id: "workflow-diagrams", topic: "Diagram templates" },
+        { id: "glossary", topic: "Project terminology" }
+      ]
+    },
+    modules: [
+      { id: "tech-writer", category: "agents" },
+      { id: "documentation-writer", category: "skills" },
+      { id: "mermaid-diagram-specialist", category: "skills" },
+      { id: "update-docs", category: "commands" },
+      { id: "markdown-format", category: "commands" },
+      { id: "documentation-standards", category: "docs", requiredBy: ["tech-writer"] },
+      { id: "workflow-diagrams", category: "docs", optional: true },
+      { id: "glossary", category: "docs", optional: true }
+    ]
+  },
+  {
+    id: "git-workflow",
+    name: "Git Workflow",
+    description: "Git commit conventions and atomic commit practices",
+    category: "workflow",
+    longDescription: "Git workflow tools including conventional commits and atomic commit helpers.",
+    tags: ["git", "commits", "workflow"],
+    complexity: "minimal",
+    responsibilities: [
+      "Conventional commit message formatting",
+      "Atomic commit enforcement",
+      "Commit message generation"
+    ],
+    scope: "Git commit workflow and conventions",
+    useCases: [
+      "Enforcing commit message standards",
+      "Generating semantic commit messages",
+      "Following atomic commit practices"
+    ],
+    moduleDetails: {
+      agents: [],
+      skills: [{ id: "git-commit-helper", purpose: "Commit message patterns" }],
+      commands: [{ id: "commit", usage: "/commit" }],
+      docs: [{ id: "atomic-commits", topic: "Atomic commit guidelines" }]
+    },
+    modules: [
+      { id: "git-commit-helper", category: "skills" },
+      { id: "commit", category: "commands" },
+      { id: "atomic-commits", category: "docs", optional: true }
+    ]
+  },
+  {
+    id: "cicd-github-actions",
+    name: "GitHub Actions CI/CD",
+    description: "GitHub Actions workflows for CI/CD automation",
+    category: "workflow",
+    longDescription: "Complete CI/CD setup with GitHub Actions including testing, quality checks, security scanning, and deployment workflows.",
+    techStack: ["GitHub Actions", "Node.js", "PNPM"],
+    tags: ["cicd", "github", "automation", "devops"],
+    complexity: "standard",
+    responsibilities: [
+      "Continuous Integration workflows",
+      "Automated testing on PRs",
+      "Code quality checks",
+      "Security scanning",
+      "Deployment automation"
+    ],
+    scope: "CI/CD pipeline automation with GitHub Actions",
+    useCases: [
+      "Automating test runs on PRs",
+      "Automated deployments to staging/production",
+      "Code quality gates",
+      "Security vulnerability scanning"
+    ],
+    moduleDetails: {
+      agents: [],
+      skills: [{ id: "github-actions-specialist", purpose: "GitHub Actions workflow patterns" }],
+      commands: [],
+      docs: [{ id: "cicd-workflows", topic: "CI/CD workflow documentation" }]
+    },
+    modules: [
+      { id: "github-actions-specialist", category: "skills", optional: true },
+      { id: "cicd-workflows", category: "docs", optional: true }
+    ]
+  }
+];
+function getAllBundles() {
+  return BUNDLES;
+}
+function getBundleById(id) {
+  return BUNDLES.find((b) => b.id === id);
+}
+
+// src/constants/mcp-servers.ts
+init_cjs_shims();
+var MCP_SERVERS = [
+  // ============================================
+  // DOCUMENTATION
+  // ============================================
+  {
+    id: "context7",
+    name: "Context7",
+    description: "Documentation lookup for libraries and frameworks",
+    package: "@anthropic/context7-mcp",
+    category: "documentation",
+    requiresConfig: false
+  },
+  // ============================================
+  // TESTING & BROWSER AUTOMATION
+  // ============================================
+  {
+    id: "chrome-devtools",
+    name: "Chrome DevTools",
+    description: "Browser automation, debugging, and performance profiling via Chrome DevTools Protocol",
+    package: "@anthropic/chrome-devtools-mcp",
+    category: "testing",
+    requiresConfig: false,
+    installInstructions: "Requires Chrome/Chromium browser installed on the system."
+  },
+  {
+    id: "playwright",
+    name: "Playwright",
+    description: "Cross-browser end-to-end testing and automation",
+    package: "@anthropic/playwright-mcp",
+    category: "testing",
+    requiresConfig: false,
+    installInstructions: "Run `npx playwright install` after setup to install browsers."
+  },
+  {
+    id: "puppeteer",
+    name: "Puppeteer",
+    description: "Headless Chrome automation for testing and scraping",
+    package: "@anthropic/puppeteer-mcp",
+    category: "testing",
+    requiresConfig: false
+  },
+  // ============================================
+  // VERSION CONTROL
+  // ============================================
+  {
+    id: "github",
+    name: "GitHub",
+    description: "GitHub API integration (issues, PRs, repos)",
+    package: "@modelcontextprotocol/server-github",
+    category: "version-control",
+    requiresConfig: true,
+    configFields: [
+      {
+        name: "token",
+        type: "string",
+        required: false,
+        description: "GitHub Personal Access Token",
+        envVar: "GITHUB_TOKEN"
+      }
+    ],
+    installInstructions: "Create a Personal Access Token at https://github.com/settings/tokens with repo, issues, and pull_request scopes."
+  },
+  {
+    id: "gitlab",
+    name: "GitLab",
+    description: "GitLab API integration (issues, MRs, repos)",
+    package: "@anthropic/gitlab-mcp",
+    category: "version-control",
+    requiresConfig: true,
+    configFields: [
+      {
+        name: "token",
+        type: "string",
+        required: false,
+        description: "GitLab Personal Access Token",
+        envVar: "GITLAB_TOKEN"
+      },
+      {
+        name: "baseUrl",
+        type: "string",
+        required: false,
+        description: "GitLab instance URL (default: https://gitlab.com)",
+        default: "https://gitlab.com"
+      }
+    ],
+    installInstructions: "Create a Personal Access Token at GitLab Settings > Access Tokens with api scope."
+  },
+  // ============================================
+  // DATABASES
+  // ============================================
+  {
+    id: "postgres",
+    name: "PostgreSQL",
+    description: "Direct PostgreSQL database access",
+    package: "@modelcontextprotocol/server-postgres",
+    category: "database",
+    requiresConfig: true,
+    configFields: [
+      {
+        name: "connectionString",
+        type: "string",
+        required: false,
+        description: "PostgreSQL connection string",
+        envVar: "DATABASE_URL"
+      }
+    ],
+    installInstructions: "Connection string format: postgresql://user:password@host:port/database"
+  },
+  {
+    id: "neon",
+    name: "Neon",
+    description: "Neon serverless PostgreSQL",
+    package: "@neondatabase/mcp-server-neon",
+    category: "database",
+    requiresConfig: true,
+    configFields: [
+      {
+        name: "apiKey",
+        type: "string",
+        required: false,
+        description: "Neon API Key",
+        envVar: "NEON_API_KEY"
+      }
+    ],
+    installInstructions: "Get your API key from https://console.neon.tech/app/settings/api-keys"
+  },
+  {
+    id: "mongodb",
+    name: "MongoDB",
+    description: "MongoDB document database access",
+    package: "@anthropic/mongodb-mcp",
+    category: "database",
+    requiresConfig: true,
+    configFields: [
+      {
+        name: "connectionString",
+        type: "string",
+        required: false,
+        description: "MongoDB connection string",
+        envVar: "MONGODB_URI"
+      }
+    ],
+    installInstructions: "Connection string format: mongodb://user:password@host:port/database or mongodb+srv://..."
+  },
+  {
+    id: "mysql",
+    name: "MySQL",
+    description: "MySQL/MariaDB database access",
+    package: "@anthropic/mysql-mcp",
+    category: "database",
+    requiresConfig: true,
+    configFields: [
+      {
+        name: "connectionString",
+        type: "string",
+        required: false,
+        description: "MySQL connection string",
+        envVar: "MYSQL_URL"
+      }
+    ],
+    installInstructions: "Connection string format: mysql://user:password@host:port/database"
+  },
+  {
+    id: "sqlite",
+    name: "SQLite",
+    description: "SQLite local database access",
+    package: "@modelcontextprotocol/server-sqlite",
+    category: "database",
+    requiresConfig: true,
+    configFields: [
+      {
+        name: "dbPath",
+        type: "string",
+        required: false,
+        description: "Path to SQLite database file",
+        default: "./data.db"
+      }
+    ]
+  },
+  {
+    id: "supabase",
+    name: "Supabase",
+    description: "Supabase backend-as-a-service (DB, Auth, Storage)",
+    package: "@supabase/mcp-server",
+    category: "database",
+    requiresConfig: true,
+    configFields: [
+      {
+        name: "url",
+        type: "string",
+        required: false,
+        description: "Supabase project URL",
+        envVar: "SUPABASE_URL"
+      },
+      {
+        name: "anonKey",
+        type: "string",
+        required: false,
+        description: "Supabase anon/public key",
+        envVar: "SUPABASE_ANON_KEY"
+      }
+    ],
+    installInstructions: "Find your project URL and anon key in Supabase Dashboard > Settings > API"
+  },
+  // ============================================
+  // CACHE & KEY-VALUE STORES
+  // ============================================
+  {
+    id: "redis",
+    name: "Redis",
+    description: "Redis cache and key-value store",
+    package: "@anthropic/redis-mcp",
+    category: "cache",
+    requiresConfig: true,
+    configFields: [
+      {
+        name: "url",
+        type: "string",
+        required: false,
+        description: "Redis connection URL",
+        envVar: "REDIS_URL",
+        default: "redis://localhost:6379"
+      }
+    ],
+    installInstructions: "Connection URL format: redis://[[user]:password@]host[:port][/db]"
+  },
+  {
+    id: "upstash",
+    name: "Upstash",
+    description: "Upstash serverless Redis and Kafka",
+    package: "@upstash/mcp-server",
+    category: "cache",
+    requiresConfig: true,
+    configFields: [
+      {
+        name: "url",
+        type: "string",
+        required: false,
+        description: "Upstash Redis REST URL",
+        envVar: "UPSTASH_REDIS_REST_URL"
+      },
+      {
+        name: "token",
+        type: "string",
+        required: false,
+        description: "Upstash Redis REST token",
+        envVar: "UPSTASH_REDIS_REST_TOKEN"
+      }
+    ],
+    installInstructions: "Get credentials from https://console.upstash.com"
+  },
+  // ============================================
+  // DEPLOYMENT & INFRASTRUCTURE
+  // ============================================
+  {
+    id: "vercel",
+    name: "Vercel",
+    description: "Vercel deployment and project management",
+    package: "@vercel/mcp",
+    category: "deployment",
+    requiresConfig: true,
+    configFields: [
+      {
+        name: "token",
+        type: "string",
+        required: false,
+        description: "Vercel Access Token",
+        envVar: "VERCEL_TOKEN"
+      }
+    ],
+    installInstructions: "Create an access token at https://vercel.com/account/tokens"
+  },
+  {
+    id: "netlify",
+    name: "Netlify",
+    description: "Netlify deployment and site management",
+    package: "@anthropic/netlify-mcp",
+    category: "deployment",
+    requiresConfig: true,
+    configFields: [
+      {
+        name: "token",
+        type: "string",
+        required: false,
+        description: "Netlify Personal Access Token",
+        envVar: "NETLIFY_TOKEN"
+      }
+    ],
+    installInstructions: "Create a token at https://app.netlify.com/user/applications#personal-access-tokens"
+  },
+  {
+    id: "cloudflare",
+    name: "Cloudflare",
+    description: "Cloudflare Workers, Pages, and DNS management",
+    package: "@cloudflare/mcp-server",
+    category: "deployment",
+    requiresConfig: true,
+    configFields: [
+      {
+        name: "apiToken",
+        type: "string",
+        required: false,
+        description: "Cloudflare API Token",
+        envVar: "CLOUDFLARE_API_TOKEN"
+      },
+      {
+        name: "accountId",
+        type: "string",
+        required: false,
+        description: "Cloudflare Account ID",
+        envVar: "CLOUDFLARE_ACCOUNT_ID"
+      }
+    ],
+    installInstructions: "Create an API token at https://dash.cloudflare.com/profile/api-tokens"
+  },
+  {
+    id: "aws",
+    name: "AWS",
+    description: "Amazon Web Services integration",
+    package: "@anthropic/aws-mcp",
+    category: "infrastructure",
+    requiresConfig: true,
+    configFields: [
+      {
+        name: "accessKeyId",
+        type: "string",
+        required: false,
+        description: "AWS Access Key ID",
+        envVar: "AWS_ACCESS_KEY_ID"
+      },
+      {
+        name: "secretAccessKey",
+        type: "string",
+        required: false,
+        description: "AWS Secret Access Key",
+        envVar: "AWS_SECRET_ACCESS_KEY"
+      },
+      {
+        name: "region",
+        type: "string",
+        required: false,
+        description: "AWS Region",
+        envVar: "AWS_REGION",
+        default: "us-east-1"
+      }
+    ],
+    installInstructions: "Create credentials in AWS IAM Console with appropriate permissions."
+  },
+  {
+    id: "docker",
+    name: "Docker",
+    description: "Docker container management",
+    package: "@anthropic/docker-mcp",
+    category: "infrastructure",
+    requiresConfig: false,
+    installInstructions: "Requires Docker Desktop or Docker Engine installed."
+  },
+  {
+    id: "kubernetes",
+    name: "Kubernetes",
+    description: "Kubernetes cluster management",
+    package: "@anthropic/kubernetes-mcp",
+    category: "infrastructure",
+    requiresConfig: true,
+    configFields: [
+      {
+        name: "kubeconfig",
+        type: "string",
+        required: false,
+        description: "Path to kubeconfig file",
+        default: "~/.kube/config"
+      },
+      {
+        name: "context",
+        type: "string",
+        required: false,
+        description: "Kubernetes context to use"
+      }
+    ],
+    installInstructions: "Requires kubectl installed and configured."
+  },
+  {
+    id: "filesystem",
+    name: "Filesystem",
+    description: "Enhanced filesystem operations",
+    package: "@modelcontextprotocol/server-filesystem",
+    category: "infrastructure",
+    requiresConfig: false
+  },
+  // ============================================
+  // PROJECT MANAGEMENT
+  // ============================================
+  {
+    id: "linear",
+    name: "Linear",
+    description: "Linear project management integration",
+    package: "@anthropic/linear-mcp",
+    category: "project-mgmt",
+    requiresConfig: true,
+    configFields: [
+      {
+        name: "apiKey",
+        type: "string",
+        required: false,
+        description: "Linear API Key",
+        envVar: "LINEAR_API_KEY"
+      }
+    ],
+    installInstructions: "Create an API key at https://linear.app/settings/api"
+  },
+  {
+    id: "jira",
+    name: "Jira",
+    description: "Atlassian Jira issue tracking",
+    package: "@anthropic/jira-mcp",
+    category: "project-mgmt",
+    requiresConfig: true,
+    configFields: [
+      {
+        name: "host",
+        type: "string",
+        required: false,
+        description: "Jira instance URL",
+        envVar: "JIRA_HOST"
+      },
+      {
+        name: "email",
+        type: "string",
+        required: false,
+        description: "Jira account email",
+        envVar: "JIRA_EMAIL"
+      },
+      {
+        name: "token",
+        type: "string",
+        required: false,
+        description: "Jira API Token",
+        envVar: "JIRA_TOKEN"
+      }
+    ],
+    installInstructions: "Create an API token at https://id.atlassian.com/manage-profile/security/api-tokens"
+  },
+  {
+    id: "notion",
+    name: "Notion",
+    description: "Notion workspace, pages, and databases",
+    package: "@anthropic/notion-mcp",
+    category: "project-mgmt",
+    requiresConfig: true,
+    configFields: [
+      {
+        name: "token",
+        type: "string",
+        required: false,
+        description: "Notion Integration Token",
+        envVar: "NOTION_TOKEN"
+      }
+    ],
+    installInstructions: "Create an integration at https://www.notion.so/my-integrations and share pages with it."
+  },
+  {
+    id: "asana",
+    name: "Asana",
+    description: "Asana project and task management",
+    package: "@anthropic/asana-mcp",
+    category: "project-mgmt",
+    requiresConfig: true,
+    configFields: [
+      {
+        name: "token",
+        type: "string",
+        required: false,
+        description: "Asana Personal Access Token",
+        envVar: "ASANA_TOKEN"
+      }
+    ],
+    installInstructions: "Create a PAT at https://app.asana.com/0/my-apps"
+  },
+  // ============================================
+  // MONITORING & OBSERVABILITY
+  // ============================================
+  {
+    id: "sentry",
+    name: "Sentry",
+    description: "Error monitoring and tracking",
+    package: "@sentry/mcp-server",
+    category: "monitoring",
+    requiresConfig: true,
+    configFields: [
+      {
+        name: "authToken",
+        type: "string",
+        required: false,
+        description: "Sentry Auth Token",
+        envVar: "SENTRY_AUTH_TOKEN"
+      },
+      {
+        name: "org",
+        type: "string",
+        required: false,
+        description: "Sentry Organization slug"
+      }
+    ],
+    installInstructions: "Create an auth token at https://sentry.io/settings/account/api/auth-tokens/"
+  },
+  {
+    id: "datadog",
+    name: "Datadog",
+    description: "Datadog monitoring and APM",
+    package: "@anthropic/datadog-mcp",
+    category: "monitoring",
+    requiresConfig: true,
+    configFields: [
+      {
+        name: "apiKey",
+        type: "string",
+        required: false,
+        description: "Datadog API Key",
+        envVar: "DD_API_KEY"
+      },
+      {
+        name: "appKey",
+        type: "string",
+        required: false,
+        description: "Datadog Application Key",
+        envVar: "DD_APP_KEY"
+      },
+      {
+        name: "site",
+        type: "string",
+        required: false,
+        description: "Datadog site (e.g., datadoghq.com)",
+        default: "datadoghq.com"
+      }
+    ],
+    installInstructions: "Find keys at https://app.datadoghq.com/organization-settings/api-keys"
+  },
+  // ============================================
+  // COMMUNICATION
+  // ============================================
+  {
+    id: "slack",
+    name: "Slack",
+    description: "Slack messaging and channel management",
+    package: "@anthropic/slack-mcp",
+    category: "communication",
+    requiresConfig: true,
+    configFields: [
+      {
+        name: "token",
+        type: "string",
+        required: false,
+        description: "Slack Bot Token (xoxb-...)",
+        envVar: "SLACK_BOT_TOKEN"
+      }
+    ],
+    installInstructions: "Create a Slack app at https://api.slack.com/apps and install to your workspace."
+  },
+  {
+    id: "discord",
+    name: "Discord",
+    description: "Discord bot and server management",
+    package: "@anthropic/discord-mcp",
+    category: "communication",
+    requiresConfig: true,
+    configFields: [
+      {
+        name: "token",
+        type: "string",
+        required: false,
+        description: "Discord Bot Token",
+        envVar: "DISCORD_BOT_TOKEN"
+      }
+    ],
+    installInstructions: "Create a bot at https://discord.com/developers/applications"
+  },
+  // ============================================
+  // DESIGN
+  // ============================================
+  {
+    id: "figma",
+    name: "Figma",
+    description: "Figma design file access and inspection",
+    package: "@anthropic/figma-mcp",
+    category: "design",
+    requiresConfig: true,
+    configFields: [
+      {
+        name: "token",
+        type: "string",
+        required: false,
+        description: "Figma Personal Access Token",
+        envVar: "FIGMA_TOKEN"
+      }
+    ],
+    installInstructions: "Create a token at https://www.figma.com/developers/api#access-tokens"
+  },
+  // ============================================
+  // PAYMENTS
+  // ============================================
+  {
+    id: "stripe",
+    name: "Stripe",
+    description: "Stripe payments API integration",
+    package: "@stripe/mcp-server",
+    category: "payments",
+    requiresConfig: true,
+    configFields: [
+      {
+        name: "secretKey",
+        type: "string",
+        required: false,
+        description: "Stripe Secret Key",
+        envVar: "STRIPE_SECRET_KEY"
+      }
+    ],
+    installInstructions: "Find your API keys at https://dashboard.stripe.com/apikeys (use test keys for development)"
+  },
+  // ============================================
+  // SEARCH
+  // ============================================
+  {
+    id: "algolia",
+    name: "Algolia",
+    description: "Algolia search and discovery",
+    package: "@anthropic/algolia-mcp",
+    category: "search",
+    requiresConfig: true,
+    configFields: [
+      {
+        name: "appId",
+        type: "string",
+        required: false,
+        description: "Algolia Application ID",
+        envVar: "ALGOLIA_APP_ID"
+      },
+      {
+        name: "apiKey",
+        type: "string",
+        required: false,
+        description: "Algolia Admin API Key",
+        envVar: "ALGOLIA_API_KEY"
+      }
+    ],
+    installInstructions: "Find credentials at https://www.algolia.com/account/api-keys/"
+  },
+  {
+    id: "elasticsearch",
+    name: "Elasticsearch",
+    description: "Elasticsearch search engine",
+    package: "@anthropic/elasticsearch-mcp",
+    category: "search",
+    requiresConfig: true,
+    configFields: [
+      {
+        name: "node",
+        type: "string",
+        required: false,
+        description: "Elasticsearch node URL",
+        envVar: "ELASTICSEARCH_NODE",
+        default: "http://localhost:9200"
+      },
+      {
+        name: "apiKey",
+        type: "string",
+        required: false,
+        description: "Elasticsearch API Key (optional)",
+        envVar: "ELASTICSEARCH_API_KEY"
+      }
+    ]
+  },
+  // ============================================
+  // AI & ML
+  // ============================================
+  {
+    id: "openai",
+    name: "OpenAI",
+    description: "OpenAI API for GPT and embeddings",
+    package: "@anthropic/openai-mcp",
+    category: "ai",
+    requiresConfig: true,
+    configFields: [
+      {
+        name: "apiKey",
+        type: "string",
+        required: false,
+        description: "OpenAI API Key",
+        envVar: "OPENAI_API_KEY"
+      }
+    ],
+    installInstructions: "Get your API key at https://platform.openai.com/api-keys"
+  },
+  {
+    id: "pinecone",
+    name: "Pinecone",
+    description: "Pinecone vector database for embeddings",
+    package: "@anthropic/pinecone-mcp",
+    category: "ai",
+    requiresConfig: true,
+    configFields: [
+      {
+        name: "apiKey",
+        type: "string",
+        required: false,
+        description: "Pinecone API Key",
+        envVar: "PINECONE_API_KEY"
+      },
+      {
+        name: "environment",
+        type: "string",
+        required: false,
+        description: "Pinecone environment",
+        envVar: "PINECONE_ENVIRONMENT"
+      }
+    ],
+    installInstructions: "Get credentials at https://app.pinecone.io/"
+  },
+  // ============================================
+  // SECURITY
+  // ============================================
+  {
+    id: "vault",
+    name: "HashiCorp Vault",
+    description: "Secrets management with HashiCorp Vault",
+    package: "@anthropic/vault-mcp",
+    category: "security",
+    requiresConfig: true,
+    configFields: [
+      {
+        name: "address",
+        type: "string",
+        required: false,
+        description: "Vault server address",
+        envVar: "VAULT_ADDR",
+        default: "http://127.0.0.1:8200"
+      },
+      {
+        name: "token",
+        type: "string",
+        required: false,
+        description: "Vault token",
+        envVar: "VAULT_TOKEN"
+      }
+    ]
+  }
+];
+
+// src/constants/dependencies.ts
+init_cjs_shims();
+var DEPENDENCIES = [
+  {
+    id: "piper-tts",
+    name: "Piper TTS",
+    description: "Text-to-speech for audio notifications",
+    requiredFor: ["hook:notification:audio"],
+    checkCommand: "command -v piper",
+    platforms: {
+      linux: {
+        commands: [
+          "pip install piper-tts",
+          "mkdir -p ~/.local/share/piper/voices",
+          "wget -O ~/.local/share/piper/voices/en_US-hfc_male-medium.onnx https://huggingface.co/rhasspy/piper-voices/resolve/main/en/en_US/hfc_male/medium/en_US-hfc_male-medium.onnx",
+          "wget -O ~/.local/share/piper/voices/en_US-hfc_male-medium.onnx.json https://huggingface.co/rhasspy/piper-voices/resolve/main/en/en_US/hfc_male/medium/en_US-hfc_male-medium.onnx.json"
+        ],
+        notes: "Requires Python 3.9+ and pip",
+        links: ["https://github.com/rhasspy/piper"]
+      },
+      macos: {
+        commands: [
+          "pip3 install piper-tts",
+          "mkdir -p ~/.local/share/piper/voices",
+          "# Download voice files from https://github.com/rhasspy/piper/releases"
+        ],
+        notes: "May need to install portaudio: brew install portaudio",
+        links: ["https://github.com/rhasspy/piper"]
+      }
+    }
+  },
+  {
+    id: "notify-send",
+    name: "libnotify",
+    description: "Desktop notifications for Linux",
+    requiredFor: ["hook:notification:desktop"],
+    checkCommand: "command -v notify-send",
+    platforms: {
+      linux: {
+        commands: [
+          "# Ubuntu/Debian:",
+          "sudo apt install libnotify-bin",
+          "# Fedora:",
+          "sudo dnf install libnotify",
+          "# Arch:",
+          "sudo pacman -S libnotify"
+        ]
+      }
+    }
+  },
+  {
+    id: "terminal-notifier",
+    name: "terminal-notifier",
+    description: "Desktop notifications for macOS",
+    requiredFor: ["hook:notification:desktop"],
+    checkCommand: "command -v terminal-notifier",
+    platforms: {
+      macos: {
+        commands: ["brew install terminal-notifier"],
+        links: ["https://github.com/julienXX/terminal-notifier"]
+      }
+    }
+  },
+  {
+    id: "jq",
+    name: "jq",
+    description: "JSON processor for hook scripts",
+    requiredFor: ["hooks"],
+    checkCommand: "command -v jq",
+    platforms: {
+      linux: {
+        commands: [
+          "# Ubuntu/Debian:",
+          "sudo apt install jq",
+          "# Fedora:",
+          "sudo dnf install jq",
+          "# Arch:",
+          "sudo pacman -S jq"
+        ]
+      },
+      macos: {
+        commands: ["brew install jq"]
+      },
+      windows: {
+        commands: ["choco install jq", "# Or: winget install jqlang.jq"]
+      }
+    }
+  },
+  {
+    id: "aplay",
+    name: "ALSA Utils",
+    description: "Audio playback for Linux",
+    requiredFor: ["hook:notification:audio"],
+    checkCommand: "command -v aplay",
+    platforms: {
+      linux: {
+        commands: [
+          "# Ubuntu/Debian:",
+          "sudo apt install alsa-utils",
+          "# Fedora:",
+          "sudo dnf install alsa-utils",
+          "# Arch:",
+          "sudo pacman -S alsa-utils"
+        ]
+      }
+    }
+  },
+  {
+    id: "afplay",
+    name: "afplay",
+    description: "Audio playback for macOS (built-in)",
+    requiredFor: ["hook:notification:audio"],
+    checkCommand: "command -v afplay",
+    platforms: {
+      macos: {
+        commands: ["# Built-in on macOS, no installation needed"],
+        notes: "afplay is included with macOS by default"
+      }
+    }
+  },
+  {
+    id: "git",
+    name: "Git",
+    description: "Version control system",
+    requiredFor: ["version-control", "remote-templates"],
+    checkCommand: "git --version",
+    platforms: {
+      linux: {
+        commands: [
+          "# Ubuntu/Debian:",
+          "sudo apt install git",
+          "# Fedora:",
+          "sudo dnf install git",
+          "# Arch:",
+          "sudo pacman -S git"
+        ]
+      },
+      macos: {
+        commands: ["brew install git", "# Or: xcode-select --install"]
+      },
+      windows: {
+        commands: ["choco install git", "# Or: winget install Git.Git"],
+        links: ["https://git-scm.com/download/win"]
+      }
+    }
+  },
+  {
+    id: "node",
+    name: "Node.js",
+    description: "JavaScript runtime",
+    requiredFor: ["cli", "mcp-servers"],
+    checkCommand: "node --version",
+    platforms: {
+      linux: {
+        commands: [
+          "# Using nvm (recommended):",
+          "curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.0/install.sh | bash",
+          "nvm install --lts",
+          "# Or using package manager:",
+          "sudo apt install nodejs npm"
+        ],
+        links: ["https://nodejs.org/", "https://github.com/nvm-sh/nvm"]
+      },
+      macos: {
+        commands: [
+          "# Using nvm (recommended):",
+          "curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.0/install.sh | bash",
+          "nvm install --lts",
+          "# Or using Homebrew:",
+          "brew install node"
+        ],
+        links: ["https://nodejs.org/", "https://github.com/nvm-sh/nvm"]
+      },
+      windows: {
+        commands: ["choco install nodejs-lts", "# Or: winget install OpenJS.NodeJS.LTS"],
+        links: ["https://nodejs.org/"]
+      }
+    }
+  }
+];
+
+// src/constants/placeholders.ts
+init_cjs_shims();
+var PLACEHOLDERS = [
+  // Project info placeholders
+  {
+    pattern: /\[Project Name\]/g,
+    configKey: "name",
+    transform: "none",
+    description: "Project name",
+    example: "My Awesome Project",
+    required: true
+  },
+  {
+    pattern: /\[project-name\]/g,
+    configKey: "name",
+    transform: "lowercase",
+    description: "Project name in lowercase with dashes",
+    example: "my-awesome-project",
+    required: true
+  },
+  {
+    pattern: /\[PROJECT_NAME\]/g,
+    configKey: "name",
+    transform: "uppercase",
+    description: "Project name in uppercase with underscores",
+    example: "MY_AWESOME_PROJECT",
+    required: true
+  },
+  {
+    pattern: /\[Project Description\]/g,
+    configKey: "description",
+    transform: "none",
+    description: "Project description",
+    example: "A powerful CLI tool for managing configurations",
+    required: true
+  },
+  {
+    pattern: /your-org/g,
+    configKey: "org",
+    transform: "lowercase",
+    description: "GitHub organization or username",
+    example: "acme-corp",
+    required: true
+  },
+  {
+    pattern: /your-repo/g,
+    configKey: "repo",
+    transform: "lowercase",
+    description: "Repository name",
+    example: "my-project",
+    required: true
+  },
+  {
+    pattern: /example\.com/g,
+    configKey: "domain",
+    transform: "lowercase",
+    description: "Project domain",
+    example: "myproject.com",
+    required: false
+  },
+  // Entity placeholders
+  {
+    pattern: /\[Entity\]/g,
+    configKey: "entityType",
+    transform: "capitalize",
+    description: "Primary entity type (capitalized)",
+    example: "Product",
+    required: true
+  },
+  {
+    pattern: /\[entity\]/g,
+    configKey: "entityType",
+    transform: "lowercase",
+    description: "Primary entity type (lowercase)",
+    example: "product",
+    required: true
+  },
+  {
+    pattern: /\[Entities\]/g,
+    configKey: "entityTypePlural",
+    transform: "capitalize",
+    description: "Primary entity type plural (capitalized)",
+    example: "Products",
+    required: true
+  },
+  {
+    pattern: /\[entities\]/g,
+    configKey: "entityTypePlural",
+    transform: "lowercase",
+    description: "Primary entity type plural (lowercase)",
+    example: "products",
+    required: true
+  },
+  // Location placeholders
+  {
+    pattern: /\[City Name\]/g,
+    configKey: "location",
+    transform: "capitalize",
+    description: "City or location name",
+    example: "San Francisco",
+    required: false
+  },
+  {
+    pattern: /\[Your Region\/Product\]/g,
+    configKey: "location",
+    transform: "none",
+    description: "Region or product area",
+    example: "Bay Area",
+    required: false
+  },
+  {
+    pattern: /\[Your product\/service tagline here\]/g,
+    configKey: "description",
+    transform: "none",
+    description: "Product tagline",
+    example: "The best way to manage your projects",
+    required: false
+  }
+];
+function applyTransform(value, transform) {
+  switch (transform) {
+    case "lowercase":
+      return value.toLowerCase().replace(/\s+/g, "-");
+    case "uppercase":
+      return value.toUpperCase().replace(/\s+/g, "_");
+    case "capitalize":
+      return value.split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
+    case "pluralize":
+      if (value.endsWith("y")) {
+        return `${value.slice(0, -1)}ies`;
+      }
+      if (value.endsWith("s") || value.endsWith("x") || value.endsWith("ch") || value.endsWith("sh")) {
+        return `${value}es`;
+      }
+      return `${value}s`;
+    default:
+      return value;
+  }
+}
+
+// src/constants/permissions.ts
+init_cjs_shims();
+var DEFAULT_FILE_PERMISSIONS = {
+  readAll: true,
+  writeCode: true,
+  writeConfig: true,
+  writeMarkdown: true,
+  writeOther: false,
+  editTool: true
+};
+var TRUST_FILE_PERMISSIONS = {
+  readAll: true,
+  writeCode: true,
+  writeConfig: true,
+  writeMarkdown: true,
+  writeOther: true,
+  editTool: true
+};
+var RESTRICTIVE_FILE_PERMISSIONS = {
+  readAll: true,
+  writeCode: false,
+  writeConfig: false,
+  writeMarkdown: true,
+  writeOther: false,
+  editTool: false
+};
+var DEFAULT_GIT_PERMISSIONS = {
+  readOnly: true,
+  staging: false,
+  commit: false,
+  push: false,
+  branching: false
+};
+var TRUST_GIT_PERMISSIONS = {
+  readOnly: true,
+  staging: true,
+  commit: true,
+  push: false,
+  branching: true
+};
+var RESTRICTIVE_GIT_PERMISSIONS = {
+  readOnly: true,
+  staging: false,
+  commit: false,
+  push: false,
+  branching: false
+};
+var DEFAULT_BASH_PERMISSIONS = {
+  packageManager: true,
+  testing: true,
+  building: true,
+  docker: false,
+  arbitrary: false
+};
+var TRUST_BASH_PERMISSIONS = {
+  packageManager: true,
+  testing: true,
+  building: true,
+  docker: true,
+  arbitrary: true
+};
+var RESTRICTIVE_BASH_PERMISSIONS = {
+  packageManager: false,
+  testing: false,
+  building: false,
+  docker: false,
+  arbitrary: false
+};
+var DEFAULT_WEB_PERMISSIONS = {
+  fetch: true,
+  search: true
+};
+var PERMISSION_PRESETS = {
+  default: {
+    files: DEFAULT_FILE_PERMISSIONS,
+    git: DEFAULT_GIT_PERMISSIONS,
+    bash: DEFAULT_BASH_PERMISSIONS,
+    web: DEFAULT_WEB_PERMISSIONS
+  },
+  trust: {
+    files: TRUST_FILE_PERMISSIONS,
+    git: TRUST_GIT_PERMISSIONS,
+    bash: TRUST_BASH_PERMISSIONS,
+    web: DEFAULT_WEB_PERMISSIONS
+  },
+  restrictive: {
+    files: RESTRICTIVE_FILE_PERMISSIONS,
+    git: RESTRICTIVE_GIT_PERMISSIONS,
+    bash: RESTRICTIVE_BASH_PERMISSIONS,
+    web: DEFAULT_WEB_PERMISSIONS
+  },
+  custom: {
+    files: DEFAULT_FILE_PERMISSIONS,
+    git: DEFAULT_GIT_PERMISSIONS,
+    bash: DEFAULT_BASH_PERMISSIONS,
+    web: DEFAULT_WEB_PERMISSIONS
+  }
+};
+
+// src/lib/bundles/resolver.ts
+init_cjs_shims();
+function resolveBundle(bundle) {
+  const modules = {
+    agents: [],
+    skills: [],
+    commands: [],
+    docs: []
+  };
+  for (const moduleRef of bundle.modules) {
+    switch (moduleRef.category) {
+      case "agents":
+        modules.agents.push(moduleRef.id);
+        break;
+      case "skills":
+        modules.skills.push(moduleRef.id);
+        break;
+      case "commands":
+        modules.commands.push(moduleRef.id);
+        break;
+      case "docs":
+        modules.docs.push(moduleRef.id);
+        break;
+    }
+  }
+  return {
+    bundle,
+    modules
+  };
+}
+function resolveBundles(bundleIds) {
+  const result = {
+    agents: [],
+    skills: [],
+    commands: [],
+    docs: []
+  };
+  const seenModules = {
+    agents: /* @__PURE__ */ new Set(),
+    skills: /* @__PURE__ */ new Set(),
+    commands: /* @__PURE__ */ new Set(),
+    docs: /* @__PURE__ */ new Set()
+  };
+  for (const bundleId of bundleIds) {
+    const bundle = getBundleById(bundleId);
+    if (!bundle) continue;
+    const resolved = resolveBundle(bundle);
+    for (const id of resolved.modules.agents) {
+      if (!seenModules.agents.has(id)) {
+        seenModules.agents.add(id);
+        result.agents.push(id);
+      }
+    }
+    for (const id of resolved.modules.skills) {
+      if (!seenModules.skills.has(id)) {
+        seenModules.skills.add(id);
+        result.skills.push(id);
+      }
+    }
+    for (const id of resolved.modules.commands) {
+      if (!seenModules.commands.has(id)) {
+        seenModules.commands.add(id);
+        result.commands.push(id);
+      }
+    }
+    for (const id of resolved.modules.docs) {
+      if (!seenModules.docs.has(id)) {
+        seenModules.docs.add(id);
+        result.docs.push(id);
+      }
+    }
+  }
+  return result;
+}
+function mergeBundleSelection(bundleResult) {
+  const result = resolveBundles(bundleResult.selectedBundles);
+  const seenModules = {
+    agents: new Set(result.agents),
+    skills: new Set(result.skills),
+    commands: new Set(result.commands),
+    docs: new Set(result.docs)
+  };
+  for (const id of bundleResult.additionalModules.agents) {
+    if (!seenModules.agents.has(id)) {
+      result.agents.push(id);
+    }
+  }
+  for (const id of bundleResult.additionalModules.skills) {
+    if (!seenModules.skills.has(id)) {
+      result.skills.push(id);
+    }
+  }
+  for (const id of bundleResult.additionalModules.commands) {
+    if (!seenModules.commands.has(id)) {
+      result.commands.push(id);
+    }
+  }
+  for (const id of bundleResult.additionalModules.docs) {
+    if (!seenModules.docs.has(id)) {
+      result.docs.push(id);
+    }
+  }
+  return result;
+}
+
+// src/lib/config/index.ts
+init_cjs_shims();
+
+// src/lib/config/reader.ts
+init_cjs_shims();
+init_fs();
+
+// src/lib/utils/logger.ts
+init_cjs_shims();
+var import_chalk = __toESM(require("chalk"), 1);
+var SYMBOLS = {
+  info: import_chalk.default.blue("\u2139"),
+  success: import_chalk.default.green("\u2714"),
+  warn: import_chalk.default.yellow("\u26A0"),
+  error: import_chalk.default.red("\u2716"),
+  debug: import_chalk.default.gray("\u25CF"),
+  arrow: import_chalk.default.cyan("\u2192"),
+  bullet: import_chalk.default.dim("\u2022")
+};
+var Logger = class {
+  verbose = false;
+  silent = false;
+  configure(options) {
+    if (options.verbose !== void 0) this.verbose = options.verbose;
+    if (options.silent !== void 0) this.silent = options.silent;
+  }
+  log(level, message, ...args) {
+    if (this.silent && level !== "error") return;
+    if (level === "debug" && !this.verbose) return;
+    const prefix = SYMBOLS[level];
+    const formattedMessage = args.length > 0 ? `${message} ${args.join(" ")}` : message;
+    switch (level) {
+      case "error":
+        console.error(`${prefix} ${import_chalk.default.red(formattedMessage)}`);
+        break;
+      case "warn":
+        console.warn(`${prefix} ${import_chalk.default.yellow(formattedMessage)}`);
+        break;
+      case "success":
+        console.log(`${prefix} ${import_chalk.default.green(formattedMessage)}`);
+        break;
+      case "debug":
+        console.log(`${prefix} ${import_chalk.default.gray(formattedMessage)}`);
+        break;
+      default:
+        console.log(`${prefix} ${formattedMessage}`);
+    }
+  }
+  debug(message, ...args) {
+    this.log("debug", message, ...args);
+  }
+  info(message, ...args) {
+    this.log("info", message, ...args);
+  }
+  success(message, ...args) {
+    this.log("success", message, ...args);
+  }
+  warn(message, ...args) {
+    this.log("warn", message, ...args);
+  }
+  error(message, ...args) {
+    this.log("error", message, ...args);
+  }
+  /**
+   * Print a blank line
+   */
+  newline() {
+    if (!this.silent) console.log();
+  }
+  /**
+   * Print a title/header
+   */
+  title(text) {
+    if (this.silent) return;
+    console.log();
+    console.log(import_chalk.default.bold(import_chalk.default.cyan(text)));
+    console.log(import_chalk.default.dim("\u2500".repeat(Math.min(text.length + 4, 60))));
+  }
+  /**
+   * Print a subtitle
+   */
+  subtitle(text) {
+    if (this.silent) return;
+    console.log();
+    console.log(import_chalk.default.bold(text));
+  }
+  /**
+   * Print a large section header for major transitions
+   * Creates a visually prominent divider between configuration sections
+   */
+  section(text, icon) {
+    if (this.silent) return;
+    const displayIcon = icon || "\u25C6";
+    const width = 60;
+    const border = "\u2550".repeat(width);
+    const innerWidth = width - 4;
+    const paddedText = text.length > innerWidth ? text.slice(0, innerWidth) : text;
+    const leftPad = Math.floor((innerWidth - paddedText.length) / 2);
+    const rightPad = innerWidth - paddedText.length - leftPad;
+    console.log();
+    console.log(import_chalk.default.cyan(`\u2554${border}\u2557`));
+    console.log(import_chalk.default.cyan("\u2551") + " ".repeat(width) + import_chalk.default.cyan("\u2551"));
+    console.log(
+      `${import_chalk.default.cyan("\u2551") + " ".repeat(leftPad + 1) + import_chalk.default.hex("#FED330")(displayIcon)} ${import_chalk.default.bold.white(paddedText)}${" ".repeat(rightPad + 1)}${import_chalk.default.cyan("\u2551")}`
+    );
+    console.log(import_chalk.default.cyan("\u2551") + " ".repeat(width) + import_chalk.default.cyan("\u2551"));
+    console.log(import_chalk.default.cyan(`\u255A${border}\u255D`));
+    console.log();
+  }
+  /**
+   * Print a step in a process
+   */
+  step(stepNumber, totalSteps, message) {
+    if (this.silent) return;
+    const progress = import_chalk.default.dim(`[${stepNumber}/${totalSteps}]`);
+    console.log(`${progress} ${message}`);
+  }
+  /**
+   * Print a list item
+   */
+  item(text, indent = 0) {
+    if (this.silent) return;
+    const spaces = "  ".repeat(indent);
+    console.log(`${spaces}${SYMBOLS.bullet} ${text}`);
+  }
+  /**
+   * Print a key-value pair
+   */
+  keyValue(key, value, indent = 0) {
+    if (this.silent) return;
+    const spaces = "  ".repeat(indent);
+    console.log(`${spaces}${import_chalk.default.dim(`${key}:`)} ${value}`);
+  }
+  /**
+   * Print an arrow item (for showing changes/actions)
+   */
+  arrow(text, indent = 0) {
+    if (this.silent) return;
+    const spaces = "  ".repeat(indent);
+    console.log(`${spaces}${SYMBOLS.arrow} ${text}`);
+  }
+  /**
+   * Print a boxed message
+   */
+  box(title, content) {
+    if (this.silent) return;
+    const maxLength = Math.max(title.length, ...content.map((line) => line.length));
+    const width = Math.min(maxLength + 4, 70);
+    const border = "\u2500".repeat(width - 2);
+    console.log();
+    console.log(import_chalk.default.cyan(`\u250C${border}\u2510`));
+    console.log(import_chalk.default.cyan("\u2502") + import_chalk.default.bold(` ${title.padEnd(width - 3)}`) + import_chalk.default.cyan("\u2502"));
+    console.log(import_chalk.default.cyan(`\u251C${border}\u2524`));
+    for (const line of content) {
+      console.log(`${import_chalk.default.cyan("\u2502")} ${line.padEnd(width - 3)}${import_chalk.default.cyan("\u2502")}`);
+    }
+    console.log(import_chalk.default.cyan(`\u2514${border}\u2518`));
+    console.log();
+  }
+  /**
+   * Print a table
+   */
+  table(headers, rows) {
+    if (this.silent) return;
+    const colWidths = headers.map((h, i) => {
+      const maxRowWidth = Math.max(...rows.map((r) => (r[i] || "").length));
+      return Math.max(h.length, maxRowWidth);
+    });
+    const headerRow = headers.map((h, i) => import_chalk.default.bold(h.padEnd(colWidths[i]))).join("  ");
+    console.log(headerRow);
+    console.log(import_chalk.default.dim(colWidths.map((w) => "\u2500".repeat(w)).join("  ")));
+    for (const row of rows) {
+      const rowStr = row.map((cell, i) => (cell || "").padEnd(colWidths[i])).join("  ");
+      console.log(rowStr);
+    }
+  }
+  /**
+   * Print a colored status
+   */
+  status(label, status) {
+    if (this.silent) return;
+    const statusColors = {
+      success: import_chalk.default.green("\u2714 done"),
+      error: import_chalk.default.red("\u2716 failed"),
+      warn: import_chalk.default.yellow("\u26A0 warning"),
+      pending: import_chalk.default.blue("\u25EF pending"),
+      skip: import_chalk.default.dim("\u25CB skipped")
+    };
+    console.log(`  ${label}: ${statusColors[status]}`);
+  }
+  /**
+   * Print instructions
+   */
+  instructions(title, steps) {
+    if (this.silent) return;
+    console.log();
+    console.log(import_chalk.default.bold(import_chalk.default.cyan(title)));
+    console.log();
+    steps.forEach((step, index) => {
+      console.log(`  ${import_chalk.default.dim(`${index + 1}.`)} ${step}`);
+    });
+    console.log();
+  }
+  /**
+   * Print a dimmed note
+   */
+  note(text) {
+    if (this.silent) return;
+    console.log(import_chalk.default.dim(`   ${text}`));
+  }
+  /**
+   * Print raw text without formatting
+   */
+  raw(text) {
+    if (this.silent) return;
+    console.log(text);
+  }
+};
+var logger = new Logger();
+var colors = {
+  primary: import_chalk.default.cyan,
+  secondary: import_chalk.default.blue,
+  success: import_chalk.default.green,
+  warning: import_chalk.default.yellow,
+  error: import_chalk.default.red,
+  muted: import_chalk.default.dim,
+  bold: import_chalk.default.bold,
+  underline: import_chalk.default.underline
+};
+
+// src/lib/config/reader.ts
+var CONFIG_FILE = "config.json";
+var CLAUDE_DIR = ".claude";
+async function readConfig(projectPath) {
+  const configPath = joinPath(projectPath, CLAUDE_DIR, CONFIG_FILE);
+  if (!await pathExists(configPath)) {
+    return null;
+  }
+  try {
+    return await readJson(configPath);
+  } catch (error) {
+    logger.debug(`Failed to read config: ${error}`);
+    return null;
+  }
+}
+async function hasConfig(projectPath) {
+  const configPath = joinPath(projectPath, CLAUDE_DIR, CONFIG_FILE);
+  return pathExists(configPath);
+}
+
+// src/lib/config/writer.ts
+init_cjs_shims();
+init_fs();
+var CONFIG_FILE2 = "config.json";
+var CLAUDE_DIR2 = ".claude";
+async function writeConfig(projectPath, config, options) {
+  const claudePath = joinPath(projectPath, CLAUDE_DIR2);
+  const configPath = joinPath(claudePath, CONFIG_FILE2);
+  await ensureDir(claudePath);
+  if (options?.backup && await pathExists(configPath)) {
+    const backupPath = await backup(configPath, `.backup.${Date.now()}`);
+    logger.debug(`Config backed up to: ${backupPath}`);
+  }
+  await writeJson(configPath, config, { spaces: 2 });
+  logger.debug(`Config written to: ${configPath}`);
+}
+function createDefaultConfig(options) {
+  return {
+    version: options.version,
+    templateSource: {
+      type: "local",
+      installedAt: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    project: options.projectInfo,
+    preferences: options.preferences,
+    mcp: {
+      level: "project",
+      servers: []
+    },
+    modules: {
+      agents: { selected: [], excluded: [] },
+      skills: { selected: [], excluded: [] },
+      commands: { selected: [], excluded: [] },
+      docs: { selected: [], excluded: [] }
+    },
+    extras: {
+      schemas: false,
+      scripts: false,
+      hooks: { enabled: false },
+      sessions: false
+    },
+    scaffold: {
+      type: "claude-only",
+      createdStructure: []
+    },
+    customizations: {
+      placeholdersReplaced: false,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+      customFiles: []
+    }
+  };
+}
+
+// src/lib/config/global-defaults.ts
+init_cjs_shims();
+var fs2 = __toESM(require("fs/promises"), 1);
+var import_node_os = require("os");
+var path2 = __toESM(require("path"), 1);
+
+// src/lib/modules/index.ts
+init_cjs_shims();
+
+// src/lib/modules/registry.ts
+init_cjs_shims();
+init_fs();
+var REGISTRY_FILE = "_registry.json";
+async function loadRegistry(templatesPath) {
+  const registry = {
+    agents: [],
+    skills: [],
+    commands: [],
+    docs: []
+  };
+  const categories = ["agents", "skills", "commands", "docs"];
+  for (const category of categories) {
+    const categoryPath = joinPath(templatesPath, category);
+    if (!await pathExists(categoryPath)) {
+      logger.debug(`Category path not found: ${categoryPath}`);
+      continue;
+    }
+    const modules = await loadCategoryModules(categoryPath, category);
+    registry[category] = modules;
+  }
+  return registry;
+}
+async function loadCategoryModules(categoryPath, category) {
+  const registryPath = joinPath(categoryPath, REGISTRY_FILE);
+  if (await pathExists(registryPath)) {
+    try {
+      const registryFile = await readJson(registryPath);
+      return registryFile.modules.map((item) => ({
+        id: item.id,
+        name: item.name,
+        description: item.description || "",
+        category,
+        file: item.file,
+        dependencies: item.dependencies || [],
+        tags: item.tags || []
+      }));
+    } catch (error) {
+      logger.debug(`Failed to load registry from ${registryPath}: ${error}`);
+    }
+  }
+  return scanCategoryDirectory(categoryPath, category);
+}
+async function scanCategoryDirectory(categoryPath, category) {
+  const modules = [];
+  const subdirs = await listDirs("*", { cwd: categoryPath });
+  for (const subdir of subdirs) {
+    if (subdir.startsWith("_")) continue;
+    const subdirPath = joinPath(categoryPath, subdir);
+    const files = await scanForModuleFiles(subdirPath);
+    for (const file of files) {
+      const id = file.replace(".md", "");
+      modules.push({
+        id,
+        name: formatName(id),
+        description: "",
+        category,
+        file: `${subdir}/${file}`,
+        dependencies: [],
+        tags: [subdir]
+      });
+    }
+  }
+  const rootFiles = await scanForModuleFiles(categoryPath);
+  for (const file of rootFiles) {
+    if (file === REGISTRY_FILE) continue;
+    const id = file.replace(".md", "");
+    modules.push({
+      id,
+      name: formatName(id),
+      description: "",
+      category,
+      file,
+      dependencies: [],
+      tags: []
+    });
+  }
+  return modules;
+}
+async function scanForModuleFiles(dirPath) {
+  const { glob: glob2 } = await import("glob");
+  const files = await glob2("*.md", { cwd: dirPath });
+  return files.filter((f) => !f.startsWith("_") && f !== "README.md");
+}
+function formatName(id) {
+  return id.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+function getModule(registry, category, id) {
+  return registry[category].find((m) => m.id === id);
+}
+
+// src/lib/modules/resolver.ts
+init_cjs_shims();
+function resolveModules(registry, category, selectedIds) {
+  const resolved = /* @__PURE__ */ new Map();
+  const unresolved = [];
+  const circular = [];
+  const visiting = /* @__PURE__ */ new Set();
+  let order = 0;
+  function visit(id) {
+    if (resolved.has(id)) return true;
+    if (visiting.has(id)) {
+      circular.push(id);
+      return false;
+    }
+    const module2 = getModule(registry, category, id);
+    if (!module2) {
+      unresolved.push(id);
+      return false;
+    }
+    visiting.add(id);
+    const resolvedDeps = [];
+    for (const depId of module2.dependencies || []) {
+      if (visit(depId)) {
+        resolvedDeps.push(depId);
+      }
+    }
+    visiting.delete(id);
+    resolved.set(id, {
+      ...module2,
+      resolvedDependencies: resolvedDeps,
+      installOrder: order++
+    });
+    return true;
+  }
+  for (const id of selectedIds) {
+    visit(id);
+  }
+  return {
+    resolved: Array.from(resolved.values()).sort((a, b) => a.installOrder - b.installOrder),
+    unresolved,
+    circular
+  };
+}
+
+// src/lib/modules/installer.ts
+init_cjs_shims();
+init_fs();
+
+// src/lib/utils/spinner.ts
+init_cjs_shims();
+var import_ora = __toESM(require("ora"), 1);
+var import_picocolors = __toESM(require("picocolors"), 1);
+var SpinnerManager = class {
+  spinner = null;
+  silent = false;
+  configure(options) {
+    if (options.silent !== void 0) this.silent = options.silent;
+  }
+  /**
+   * Start a spinner with a message
+   */
+  start(text, options) {
+    if (this.silent) return null;
+    this.stop();
+    this.spinner = (0, import_ora.default)({
+      text,
+      color: options?.color || "cyan",
+      spinner: "dots"
+    }).start();
+    return this.spinner;
+  }
+  /**
+   * Update spinner text
+   */
+  text(text) {
+    if (this.spinner) {
+      this.spinner.text = text;
+    }
+  }
+  /**
+   * Stop spinner with success message
+   */
+  succeed(text) {
+    if (this.spinner) {
+      this.spinner.succeed(text);
+      this.spinner = null;
+    }
+  }
+  /**
+   * Stop spinner with failure message
+   */
+  fail(text) {
+    if (this.spinner) {
+      this.spinner.fail(text);
+      this.spinner = null;
+    }
+  }
+  /**
+   * Stop spinner with warning message
+   */
+  warn(text) {
+    if (this.spinner) {
+      this.spinner.warn(text);
+      this.spinner = null;
+    }
+  }
+  /**
+   * Stop spinner with info message
+   */
+  info(text) {
+    if (this.spinner) {
+      this.spinner.info(text);
+      this.spinner = null;
+    }
+  }
+  /**
+   * Stop spinner without message
+   */
+  stop() {
+    if (this.spinner) {
+      this.spinner.stop();
+      this.spinner = null;
+    }
+  }
+  /**
+   * Check if spinner is running
+   */
+  isRunning() {
+    return this.spinner?.isSpinning ?? false;
+  }
+};
+var spinner = new SpinnerManager();
+async function withSpinner(text, operation, options) {
+  if (options?.silent) {
+    return operation();
+  }
+  spinner.start(text);
+  try {
+    const result = await operation();
+    spinner.succeed(options?.successText || text);
+    return result;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail(options?.failText || `${text} - ${import_picocolors.default.red(errorMessage)}`);
+    throw error;
+  }
+}
+
+// src/lib/modules/installer.ts
+function removeConfigRequiredFromFrontmatter(content) {
+  const frontmatterRegex = /^---\n([\s\S]*?)\n---/;
+  const match = content.match(frontmatterRegex);
+  if (!match) {
+    return content;
+  }
+  const frontmatter = match[1];
+  const configRequiredRegex = /config_required:\s*\n(?:\s+-\s+[^\n]+\n?)*/g;
+  const cleanedFrontmatter = frontmatter.replace(configRequiredRegex, "").trim();
+  const restOfFile = content.slice(match[0].length);
+  if (cleanedFrontmatter.trim() === "") {
+    return restOfFile.trim();
+  }
+  return `---
+${cleanedFrontmatter}
+---${restOfFile}`;
+}
+async function processModuleFile(filePath) {
+  if (!filePath.endsWith(".md")) {
+    return;
+  }
+  try {
+    const content = await readFile(filePath);
+    const cleanedContent = removeConfigRequiredFromFrontmatter(content);
+    if (cleanedContent !== content) {
+      await writeFile(filePath, cleanedContent);
+      logger.debug(`Cleaned config_required from: ${filePath}`);
+    }
+  } catch (error) {
+    logger.debug(`Failed to process module file ${filePath}: ${error}`);
+  }
+}
+async function installModules(category, modules, options) {
+  const result = {
+    success: true,
+    installed: [],
+    skipped: [],
+    failed: []
+  };
+  const categorySourcePath = joinPath(options.templatesPath, category);
+  const categoryTargetPath = joinPath(options.targetPath, ".claude", category);
+  if (!options.dryRun) {
+    await ensureDir(categoryTargetPath);
+  }
+  for (const module2 of modules) {
+    try {
+      const sourcePath = joinPath(categorySourcePath, module2.file);
+      const targetPath = joinPath(categoryTargetPath, module2.file);
+      if (!await pathExists(sourcePath)) {
+        result.failed.push({ id: module2.id, error: `Source file not found: ${sourcePath}` });
+        result.success = false;
+        continue;
+      }
+      const targetExists = await pathExists(targetPath);
+      if (targetExists && !options.overwrite) {
+        result.skipped.push(module2.id);
+        continue;
+      }
+      if (options.dryRun) {
+        logger.debug(`Would install: ${module2.id} -> ${targetPath}`);
+        result.installed.push(module2.id);
+        continue;
+      }
+      await ensureDir(dirname(targetPath));
+      await copy(sourcePath, targetPath, { overwrite: options.overwrite });
+      await processModuleFile(targetPath);
+      result.installed.push(module2.id);
+      logger.debug(`Installed: ${module2.id}`);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      result.failed.push({ id: module2.id, error: errorMessage });
+      result.success = false;
+    }
+  }
+  return result;
+}
+
+// src/lib/placeholders/index.ts
+init_cjs_shims();
+
+// src/lib/placeholders/replacer.ts
+init_cjs_shims();
+init_fs();
+async function replaceInFile(filePath, projectInfo, placeholders = PLACEHOLDERS) {
+  const replacements = [];
+  let content = await readFile(filePath);
+  let modified = false;
+  for (const placeholder of placeholders) {
+    const value = projectInfo[placeholder.configKey];
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    const transformedValue = applyTransform(String(value), placeholder.transform);
+    const pattern = placeholder.pattern;
+    if (pattern instanceof RegExp) {
+      const matches = content.matchAll(new RegExp(pattern.source, "g"));
+      for (const match of matches) {
+        const lineNumber = getLineNumber(content, match.index ?? 0);
+        replacements.push({
+          file: filePath,
+          line: lineNumber,
+          original: match[0],
+          replacement: transformedValue,
+          placeholder
+        });
+      }
+      if (pattern.test(content)) {
+        content = content.replace(pattern, transformedValue);
+        modified = true;
+      }
+    } else {
+      const regex = new RegExp(escapeRegex(pattern), "g");
+      const matches = content.matchAll(regex);
+      for (const match of matches) {
+        const lineNumber = getLineNumber(content, match.index ?? 0);
+        replacements.push({
+          file: filePath,
+          line: lineNumber,
+          original: match[0],
+          replacement: transformedValue,
+          placeholder
+        });
+      }
+      if (content.includes(pattern)) {
+        content = content.replace(regex, transformedValue);
+        modified = true;
+      }
+    }
+  }
+  if (modified) {
+    await writeFile(filePath, content);
+  }
+  return replacements;
+}
+async function replaceInDirectory(dirPath, projectInfo, options) {
+  const extensions = options?.extensions || ["md", "json", "yaml", "yml", "ts", "js", "tsx", "jsx"];
+  const exclude = options?.exclude || ["node_modules", ".git", "dist", "build"];
+  const pattern = `**/*.{${extensions.join(",")}}`;
+  const files = await listFiles(pattern, {
+    cwd: dirPath,
+    ignore: exclude.map((e) => `**/${e}/**`)
+  });
+  const report = {
+    totalFiles: files.length,
+    filesModified: 0,
+    replacements: [],
+    unreplacedPlaceholders: []
+  };
+  for (const file of files) {
+    const filePath = joinPath(dirPath, file);
+    try {
+      const replacements = options?.dryRun ? await scanFile(filePath, projectInfo) : await replaceInFile(filePath, projectInfo);
+      if (replacements.length > 0) {
+        report.filesModified++;
+        report.replacements.push(...replacements);
+      }
+    } catch (error) {
+      logger.debug(`Failed to process ${file}: ${error}`);
+    }
+  }
+  report.unreplacedPlaceholders = findUnreplacedPlaceholders(projectInfo);
+  return report;
+}
+async function scanFile(filePath, projectInfo) {
+  const replacements = [];
+  const content = await readFile(filePath);
+  for (const placeholder of PLACEHOLDERS) {
+    const value = projectInfo[placeholder.configKey];
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    const transformedValue = applyTransform(String(value), placeholder.transform);
+    const pattern = placeholder.pattern;
+    const regex = pattern instanceof RegExp ? new RegExp(pattern.source, "g") : new RegExp(escapeRegex(pattern), "g");
+    const matches = content.matchAll(regex);
+    for (const match of matches) {
+      const lineNumber = getLineNumber(content, match.index ?? 0);
+      replacements.push({
+        file: filePath,
+        line: lineNumber,
+        original: match[0],
+        replacement: transformedValue,
+        placeholder
+      });
+    }
+  }
+  return replacements;
+}
+async function replacePlaceholders(dirPath, projectInfo, options) {
+  return withSpinner(
+    "Replacing placeholders...",
+    () => replaceInDirectory(dirPath, projectInfo, options),
+    {
+      successText: "Placeholders replaced",
+      silent: options?.silent || options?.dryRun
+    }
+  );
+}
+function findUnreplacedPlaceholders(projectInfo) {
+  const unreplaced = [];
+  for (const placeholder of PLACEHOLDERS) {
+    if (!placeholder.required) continue;
+    const value = projectInfo[placeholder.configKey];
+    if (value === void 0 || value === null || value === "") {
+      const patternStr = placeholder.pattern instanceof RegExp ? placeholder.pattern.source : placeholder.pattern;
+      unreplaced.push(patternStr);
+    }
+  }
+  return unreplaced;
+}
+function getLineNumber(content, index) {
+  return content.slice(0, index).split("\n").length;
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/lib/scaffold/detector.ts
+init_cjs_shims();
+init_fs();
+async function detectProject(projectPath) {
+  const signals = [];
+  const packageJsonPath = joinPath(projectPath, "package.json");
+  const hasPackageJson = await pathExists(packageJsonPath);
+  if (!hasPackageJson) {
+    return {
+      detected: false,
+      confidence: "low",
+      signals: [{ file: "package.json", exists: false, indicates: "not a Node.js project" }]
+    };
+  }
+  signals.push({ file: "package.json", exists: true, indicates: "Node.js project" });
+  const packageJson = await readJson(packageJsonPath).catch(() => ({}));
+  const packageManager = await detectPackageManager(projectPath);
+  if (packageManager) {
+    signals.push({
+      file: `${packageManager}-lock`,
+      exists: true,
+      indicates: `${packageManager} package manager`
+    });
+  }
+  const typeResult = await detectProjectType(projectPath, packageJson);
+  const projectType = typeResult.type;
+  signals.push(...typeResult.signals);
+  const confidence = projectType && packageManager ? "high" : projectType || packageManager ? "medium" : "low";
+  const suggestedBundles = suggestBundles(projectType, packageJson);
+  return {
+    detected: true,
+    projectType,
+    packageManager,
+    suggestedBundles,
+    confidence,
+    signals
+  };
+}
+async function detectPackageManager(projectPath) {
+  const lockFiles = [
+    { file: "pnpm-lock.yaml", manager: "pnpm" },
+    { file: "yarn.lock", manager: "yarn" },
+    { file: "package-lock.json", manager: "npm" },
+    { file: "bun.lockb", manager: "bun" }
+  ];
+  for (const { file, manager } of lockFiles) {
+    if (await pathExists(joinPath(projectPath, file))) {
+      return manager;
+    }
+  }
+  return void 0;
+}
+async function detectProjectType(projectPath, packageJson) {
+  const signals = [];
+  const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+  if (await pathExists(joinPath(projectPath, "turbo.json")) || await pathExists(joinPath(projectPath, "pnpm-workspace.yaml")) || packageJson.workspaces) {
+    signals.push({ file: "turbo.json/pnpm-workspace.yaml", exists: true, indicates: "monorepo" });
+    return { type: "monorepo", signals };
+  }
+  if (await pathExists(joinPath(projectPath, "astro.config.mjs")) || await pathExists(joinPath(projectPath, "astro.config.ts")) || deps.astro) {
+    signals.push({ file: "astro.config.*", exists: true, indicates: "Astro project" });
+    return { type: "astro", signals };
+  }
+  if (await pathExists(joinPath(projectPath, "next.config.js")) || await pathExists(joinPath(projectPath, "next.config.mjs")) || await pathExists(joinPath(projectPath, "next.config.ts")) || deps.next) {
+    signals.push({ file: "next.config.*", exists: true, indicates: "Next.js project" });
+    return { type: "nextjs", signals };
+  }
+  if ((await pathExists(joinPath(projectPath, "vite.config.ts")) || await pathExists(joinPath(projectPath, "vite.config.js"))) && (deps.react || deps["react-dom"])) {
+    signals.push({ file: "vite.config.*", exists: true, indicates: "Vite project" });
+    signals.push({ file: "react dependency", exists: true, indicates: "React project" });
+    return { type: "vite-react", signals };
+  }
+  if (deps.hono) {
+    signals.push({ file: "hono dependency", exists: true, indicates: "Hono API project" });
+    return { type: "hono", signals };
+  }
+  if (deps.typescript || await pathExists(joinPath(projectPath, "tsconfig.json"))) {
+    signals.push({ file: "tsconfig.json", exists: true, indicates: "TypeScript project" });
+    return { type: "node", signals };
+  }
+  return { type: "node", signals };
+}
+function suggestBundles(projectType, packageJson) {
+  const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+  const suggestedBundles = [];
+  const hasHono = deps.hono || deps["@hono/node-server"];
+  const hasExpress = deps.express;
+  const hasFastify = deps.fastify;
+  const hasNestjs = deps["@nestjs/core"];
+  const hasDrizzle = deps.drizzle || deps["drizzle-orm"];
+  const hasPrisma = deps.prisma || deps["@prisma/client"];
+  const hasMongoose = deps.mongoose;
+  const hasReact = deps.react;
+  const hasTanstack = deps["@tanstack/react-router"] || deps["@tanstack/start"];
+  switch (projectType) {
+    case "astro":
+      suggestedBundles.push("astro-react-stack");
+      break;
+    case "nextjs":
+      if (hasPrisma) {
+        suggestedBundles.push("nextjs-prisma-stack");
+      } else {
+        suggestedBundles.push("react-tanstack-stack");
+      }
+      break;
+    case "vite-react":
+      suggestedBundles.push("react-tanstack-stack");
+      break;
+    case "hono":
+      if (hasDrizzle) {
+        suggestedBundles.push("hono-drizzle-stack");
+      } else if (hasPrisma) {
+        suggestedBundles.push("hono-api");
+        suggestedBundles.push("prisma-database");
+      } else {
+        suggestedBundles.push("hono-api");
+      }
+      break;
+    case "monorepo":
+      if (hasReact && hasTanstack) {
+        suggestedBundles.push("react-tanstack-stack");
+      }
+      if (hasHono && hasDrizzle) {
+        suggestedBundles.push("hono-drizzle-stack");
+      } else if (hasHono) {
+        suggestedBundles.push("hono-api");
+      }
+      break;
+    case "node":
+      if (hasHono) {
+        if (hasDrizzle) {
+          suggestedBundles.push("hono-drizzle-stack");
+        } else {
+          suggestedBundles.push("hono-api");
+        }
+      } else if (hasExpress) {
+        if (hasPrisma) {
+          suggestedBundles.push("express-prisma-stack");
+        } else {
+          suggestedBundles.push("express-api");
+        }
+      } else if (hasFastify) {
+        suggestedBundles.push("fastify-api");
+      } else if (hasNestjs) {
+        suggestedBundles.push("nestjs-api");
+      }
+      break;
+  }
+  if (hasDrizzle && !suggestedBundles.some((b) => b.includes("drizzle"))) {
+    suggestedBundles.push("drizzle-database");
+  }
+  if (hasPrisma && !suggestedBundles.some((b) => b.includes("prisma"))) {
+    suggestedBundles.push("prisma-database");
+  }
+  if (hasMongoose) {
+    suggestedBundles.push("mongoose-database");
+  }
+  if (suggestedBundles.length > 0) {
+    suggestedBundles.push("testing-minimal");
+    suggestedBundles.push("quality-minimal");
+  }
+  suggestedBundles.push("git-workflow");
+  return suggestedBundles;
+}
+
+// src/lib/templates/index.ts
+init_cjs_shims();
+
+// src/lib/templates/parser.ts
+init_cjs_shims();
+var DIRECTIVE_PATTERNS = {
+  // Block directives: {{#type expression}}...{{/type}}
+  block: /\{\{#(if|unless|each|section)\s+([^}]+)\}\}([\s\S]*?)\{\{\/\1\}\}/g,
+  // Include directive: {{> partialName}}
+  include: /\{\{>\s*([^}]+)\}\}/g,
+  // Variable with optional transform: {{variable}} or {{variable | transform}}
+  variable: /\{\{([^#/>][^}|]*?)(?:\s*\|\s*(\w+))?\}\}/g
+};
+function parseDirectives(content) {
+  const directives = [];
+  const blockMatches = content.matchAll(DIRECTIVE_PATTERNS.block);
+  for (const match of blockMatches) {
+    const [fullMatch, type, expression, innerContent] = match;
+    const startIndex = match.index ?? 0;
+    directives.push({
+      type,
+      match: fullMatch,
+      expression: expression.trim(),
+      content: innerContent,
+      startIndex,
+      endIndex: startIndex + fullMatch.length,
+      nested: parseDirectives(innerContent)
+      // Recursive parse for nested directives
+    });
+  }
+  const includeMatches = content.matchAll(DIRECTIVE_PATTERNS.include);
+  for (const match of includeMatches) {
+    const [fullMatch, partialName] = match;
+    const startIndex = match.index ?? 0;
+    directives.push({
+      type: "include",
+      match: fullMatch,
+      expression: partialName.trim(),
+      startIndex,
+      endIndex: startIndex + fullMatch.length
+    });
+  }
+  return directives;
+}
+function parseExpression(expression) {
+  const comparisonMatch = expression.match(/^(\S+)\s*(==|!=|>=|<=|>|<)\s*(.+)$/);
+  if (comparisonMatch) {
+    const [, variable2, operator, compareValue] = comparisonMatch;
+    return {
+      variable: variable2.trim(),
+      path: variable2.trim().split("."),
+      operator,
+      compareValue: compareValue.trim().replace(/^["']|["']$/g, "")
+    };
+  }
+  if (expression.startsWith("!")) {
+    const variable2 = expression.slice(1).trim();
+    return {
+      variable: variable2,
+      path: variable2.split("."),
+      operator: "!"
+    };
+  }
+  const variable = expression.trim();
+  return {
+    variable,
+    path: variable.split(".")
+  };
+}
+function findVariables(content) {
+  const variables = [];
+  const matches = content.matchAll(DIRECTIVE_PATTERNS.variable);
+  for (const match of matches) {
+    const [fullMatch, variable, transform] = match;
+    if (variable.startsWith("#") || variable.startsWith("/") || variable.startsWith(">")) {
+      continue;
+    }
+    variables.push({
+      match: fullMatch,
+      variable: variable.trim(),
+      transform: transform?.trim(),
+      index: match.index ?? 0
+    });
+  }
+  return variables;
+}
+function hasDirectives(content) {
+  return /\{\{[#/>]?\s*\w/.test(content);
+}
+function validateTemplate(content) {
+  const errors = [];
+  const openBlocks = [];
+  const openMatches = content.matchAll(/\{\{#(if|unless|each|section)\s+[^}]+\}\}/g);
+  for (const match of openMatches) {
+    openBlocks.push({
+      type: match[1],
+      index: match.index ?? 0
+    });
+  }
+  const closeMatches = content.matchAll(/\{\{\/(if|unless|each|section)\}\}/g);
+  const closeBlocks = [];
+  for (const match of closeMatches) {
+    closeBlocks.push(match[1]);
+  }
+  if (openBlocks.length !== closeBlocks.length) {
+    errors.push(
+      `Mismatched block directives: ${openBlocks.length} opening, ${closeBlocks.length} closing`
+    );
+  }
+  const unclosedVars = content.match(/\{\{(?![^}]*\}\})/g);
+  if (unclosedVars) {
+    errors.push(`Found ${unclosedVars.length} unclosed variable reference(s)`);
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+// src/lib/templates/evaluator.ts
+init_cjs_shims();
+function getContextValue(context, path5) {
+  const parts = path5.split(".");
+  let current = context;
+  for (const part of parts) {
+    if (current === void 0 || current === null) {
+      return void 0;
+    }
+    current = current[part];
+  }
+  return current;
+}
+function evaluateCondition(expression, context) {
+  const parsed = parseExpression(expression);
+  if (expression.includes("&&")) {
+    const parts = expression.split("&&").map((p) => p.trim());
+    return parts.every((part) => evaluateCondition(part, context));
+  }
+  if (expression.includes("||")) {
+    const parts = expression.split("||").map((p) => p.trim());
+    return parts.some((part) => evaluateCondition(part, context));
+  }
+  const value = getContextValue(context, parsed.variable);
+  if (parsed.operator === "!") {
+    return !isTruthy(value);
+  }
+  if (parsed.operator && parsed.compareValue !== void 0) {
+    const compareValue = parsed.compareValue;
+    switch (parsed.operator) {
+      case "==":
+        return String(value) === compareValue;
+      case "!=":
+        return String(value) !== compareValue;
+      case ">":
+        return Number(value) > Number(compareValue);
+      case ">=":
+        return Number(value) >= Number(compareValue);
+      case "<":
+        return Number(value) < Number(compareValue);
+      case "<=":
+        return Number(value) <= Number(compareValue);
+      default:
+        return false;
+    }
+  }
+  if (expression.includes(".includes(")) {
+    const match = expression.match(/^(.+?)\.includes\(["'](.+?)["']\)$/);
+    if (match) {
+      const [, arrayPath, searchValue] = match;
+      const arrayValue = getContextValue(context, arrayPath);
+      if (Array.isArray(arrayValue)) {
+        return arrayValue.includes(searchValue);
+      }
+    }
+    return false;
+  }
+  if (expression.startsWith("has ")) {
+    const match = expression.match(/^has\s+(\S+)\s+["']?(.+?)["']?$/);
+    if (match) {
+      const [, arrayPath, searchValue] = match;
+      const arrayValue = getContextValue(context, arrayPath);
+      if (Array.isArray(arrayValue)) {
+        return arrayValue.includes(searchValue);
+      }
+    }
+    return false;
+  }
+  return isTruthy(value);
+}
+function isTruthy(value) {
+  if (value === void 0 || value === null) {
+    return false;
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "string") {
+    return value.length > 0;
+  }
+  if (typeof value === "number") {
+    return value !== 0;
+  }
+  if (Array.isArray(value)) {
+    return value.length > 0;
+  }
+  if (typeof value === "object") {
+    return Object.keys(value).length > 0;
+  }
+  return Boolean(value);
+}
+function getIterable(expression, context) {
+  const value = getContextValue(context, expression);
+  if (Array.isArray(value)) {
+    return value.map((item, index) => ({ item, index }));
+  }
+  if (typeof value === "object" && value !== null) {
+    return Object.entries(value).map(([key, item], index) => ({
+      item,
+      index,
+      key
+    }));
+  }
+  return [];
+}
+function applyTemplateTransform(value, transform) {
+  if (value === void 0 || value === null) {
+    return "";
+  }
+  const strValue = Array.isArray(value) ? value.join(", ") : String(value);
+  switch (transform.toLowerCase()) {
+    case "lowercase":
+    case "lower":
+      return strValue.toLowerCase();
+    case "uppercase":
+    case "upper":
+      return strValue.toUpperCase();
+    case "capitalize":
+    case "title":
+      return strValue.split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
+    case "kebab":
+    case "kebabcase":
+      return strValue.toLowerCase().replace(/\s+/g, "-");
+    case "snake":
+    case "snakecase":
+      return strValue.toLowerCase().replace(/\s+/g, "_");
+    case "camel":
+    case "camelcase":
+      return strValue.split(/[\s-_]+/).map(
+        (word, i) => i === 0 ? word.toLowerCase() : word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()
+      ).join("");
+    case "pascal":
+    case "pascalcase":
+      return strValue.split(/[\s-_]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+    case "json":
+      return JSON.stringify(value);
+    case "count":
+      return String(Array.isArray(value) ? value.length : strValue.length);
+    case "first":
+      if (Array.isArray(value)) {
+        return String(value[0] ?? "");
+      }
+      return strValue;
+    case "last":
+      if (Array.isArray(value)) {
+        return String(value[value.length - 1] ?? "");
+      }
+      return strValue;
+    case "join":
+      if (Array.isArray(value)) {
+        return value.join(", ");
+      }
+      return strValue;
+    case "joinlines":
+      if (Array.isArray(value)) {
+        return value.join("\n");
+      }
+      return strValue;
+    case "bullet":
+    case "bullets":
+      if (Array.isArray(value)) {
+        return value.map((v) => `- ${v}`).join("\n");
+      }
+      return `- ${strValue}`;
+    case "numbered":
+      if (Array.isArray(value)) {
+        return value.map((v, i) => `${i + 1}. ${v}`).join("\n");
+      }
+      return `1. ${strValue}`;
+    default:
+      return strValue;
+  }
+}
+function createLoopContext(parentContext, itemValue, index, key) {
+  return {
+    ...parentContext,
+    item: itemValue,
+    index,
+    key
+  };
+}
+
+// src/lib/templates/processor.ts
+init_cjs_shims();
+init_fs();
+function processTemplate(content, context) {
+  const result = {
+    content,
+    modified: false,
+    directivesProcessed: 0,
+    warnings: [],
+    errors: []
+  };
+  const validation = validateTemplate(content);
+  if (!validation.valid) {
+    result.errors.push(...validation.errors);
+    return result;
+  }
+  if (!hasDirectives(content)) {
+    return result;
+  }
+  try {
+    result.content = processBlockDirectives(result.content, context, result);
+    result.content = processVariables(result.content, context, result);
+    result.content = cleanupEmptyLines(result.content);
+    result.modified = result.content !== content;
+  } catch (error) {
+    result.errors.push(`Template processing error: ${error}`);
+  }
+  return result;
+}
+function processBlockDirectives(content, context, result) {
+  const directives = parseDirectives(content);
+  const sortedDirectives = [...directives].sort((a, b) => b.startIndex - a.startIndex);
+  for (const directive of sortedDirectives) {
+    const replacement = processDirective(directive, context, result);
+    content = content.slice(0, directive.startIndex) + replacement + content.slice(directive.endIndex);
+    result.directivesProcessed++;
+  }
+  return content;
+}
+function processDirective(directive, context, result) {
+  switch (directive.type) {
+    case "if":
+      return processIfDirective(directive, context, result);
+    case "unless":
+      return processUnlessDirective(directive, context, result);
+    case "each":
+      return processEachDirective(directive, context, result);
+    case "section":
+      return processSectionDirective(directive, context, result);
+    case "include":
+      result.warnings.push(`Include directive not yet supported: ${directive.expression}`);
+      return directive.match;
+    default:
+      result.warnings.push(`Unknown directive type: ${directive.type}`);
+      return directive.match;
+  }
+}
+function processIfDirective(directive, context, result) {
+  const condition = evaluateCondition(directive.expression, context);
+  if (condition) {
+    const innerContent = directive.content ?? "";
+    const innerResult = processTemplate(innerContent, context);
+    result.warnings.push(...innerResult.warnings);
+    result.errors.push(...innerResult.errors);
+    return innerResult.content;
+  }
+  return "";
+}
+function processUnlessDirective(directive, context, result) {
+  const condition = evaluateCondition(directive.expression, context);
+  if (!condition) {
+    const innerContent = directive.content ?? "";
+    const innerResult = processTemplate(innerContent, context);
+    result.warnings.push(...innerResult.warnings);
+    result.errors.push(...innerResult.errors);
+    return innerResult.content;
+  }
+  return "";
+}
+function processEachDirective(directive, context, result) {
+  const items = getIterable(directive.expression, context);
+  if (items.length === 0) {
+    return "";
+  }
+  const outputs = [];
+  for (const { item, index, key } of items) {
+    const loopContext = createLoopContext(context, item, index, key);
+    const innerContent = directive.content ?? "";
+    const innerResult = processTemplate(innerContent, loopContext);
+    result.warnings.push(...innerResult.warnings);
+    result.errors.push(...innerResult.errors);
+    outputs.push(innerResult.content);
+  }
+  return outputs.join("");
+}
+function processSectionDirective(directive, context, result) {
+  const innerContent = directive.content ?? "";
+  const innerResult = processTemplate(innerContent, context);
+  result.warnings.push(...innerResult.warnings);
+  result.errors.push(...innerResult.errors);
+  return innerResult.content;
+}
+function processVariables(content, context, result) {
+  const variables = findVariables(content);
+  const sortedVariables = [...variables].sort((a, b) => b.index - a.index);
+  for (const { match, variable, transform, index } of sortedVariables) {
+    const value = getContextValue(context, variable);
+    if (value !== void 0) {
+      const replacement = transform ? applyTemplateTransform(value, transform) : String(value);
+      content = content.slice(0, index) + replacement + content.slice(index + match.length);
+      result.directivesProcessed++;
+    } else {
+      result.warnings.push(`Variable not found: ${variable}`);
+    }
+  }
+  return content;
+}
+function cleanupEmptyLines(content) {
+  return content.replace(/\n{3,}/g, "\n\n").trim();
+}
+async function processTemplatesInDirectory(dirPath, context, options) {
+  const extensions = options?.extensions ?? ["md", "json", "yaml", "yml"];
+  const exclude = options?.exclude ?? ["node_modules", ".git", "dist", "build"];
+  const pattern = `**/*.{${extensions.join(",")}}`;
+  const files = await listFiles(pattern, {
+    cwd: dirPath,
+    ignore: exclude.map((e) => `**/${e}/**`)
+  });
+  const report = {
+    totalFiles: files.length,
+    filesModified: 0,
+    totalDirectives: 0,
+    filesWithErrors: [],
+    warnings: []
+  };
+  for (const file of files) {
+    const filePath = joinPath(dirPath, file);
+    try {
+      const content = await readFile(filePath);
+      if (!hasDirectives(content)) {
+        continue;
+      }
+      const result = processTemplate(content, context);
+      if (result.errors.length > 0) {
+        report.filesWithErrors.push(file);
+        report.warnings.push(`${file}: ${result.errors.join(", ")}`);
+        continue;
+      }
+      if (result.modified) {
+        if (!options?.dryRun) {
+          await writeFile(filePath, result.content);
+        }
+        report.filesModified++;
+      }
+      report.totalDirectives += result.directivesProcessed;
+      report.warnings.push(...result.warnings.map((w) => `${file}: ${w}`));
+    } catch (error) {
+      logger.debug(`Failed to process template ${file}: ${error}`);
+      report.filesWithErrors.push(file);
+    }
+  }
+  return report;
+}
+async function processTemplates(dirPath, context, options) {
+  return withSpinner(
+    "Processing templates...",
+    () => processTemplatesInDirectory(dirPath, context, options),
+    {
+      successText: "Templates processed",
+      silent: options?.silent ?? options?.dryRun
+    }
+  );
+}
+
+// src/lib/templates/context.ts
+init_cjs_shims();
+function buildTemplateContext(config) {
+  const getModuleIds2 = (selection) => {
+    return selection?.selected ?? [];
+  };
+  const getMcpServerIds = (servers) => {
+    return servers?.map((s) => s.serverId) ?? [];
+  };
+  const context = {
+    project: {
+      name: config.project?.name,
+      description: config.project?.description,
+      org: config.project?.org,
+      repo: config.project?.repo,
+      domain: config.project?.domain,
+      entityType: config.project?.entityType,
+      location: config.project?.location
+    },
+    modules: {
+      agents: getModuleIds2(config.modules?.agents),
+      skills: getModuleIds2(config.modules?.skills),
+      commands: getModuleIds2(config.modules?.commands),
+      docs: getModuleIds2(config.modules?.docs)
+    },
+    codeStyle: {
+      formatter: config.extras?.codeStyle?.biome ? "biome" : config.extras?.codeStyle?.prettier ? "prettier" : "none",
+      linter: config.extras?.codeStyle?.biome ? "biome" : "none",
+      editorConfig: config.extras?.codeStyle?.editorconfig,
+      commitlint: config.extras?.codeStyle?.commitlint
+    },
+    techStack: {},
+    bundles: [],
+    mcpServers: getMcpServerIds(config.mcp?.servers),
+    custom: {}
+  };
+  context.techStack = inferTechStack(context.modules);
+  return context;
+}
+function inferTechStack(modules) {
+  const techStack = {};
+  const allModules = [
+    ...modules.agents,
+    ...modules.skills,
+    ...modules.commands,
+    ...modules.docs
+  ];
+  if (allModules.some((m) => m.includes("nextjs"))) {
+    techStack.framework = "nextjs";
+  } else if (allModules.some((m) => m.includes("astro"))) {
+    techStack.framework = "astro";
+  } else if (allModules.some((m) => m.includes("tanstack-start"))) {
+    techStack.framework = "tanstack-start";
+  } else if (allModules.some((m) => m.includes("react"))) {
+    techStack.framework = "react";
+  }
+  if (allModules.some((m) => m.includes("prisma"))) {
+    techStack.orm = "prisma";
+  } else if (allModules.some((m) => m.includes("drizzle"))) {
+    techStack.orm = "drizzle";
+  } else if (allModules.some((m) => m.includes("mongoose"))) {
+    techStack.orm = "mongoose";
+  }
+  if (allModules.some((m) => m.includes("hono"))) {
+    techStack.database = "hono";
+  } else if (allModules.some((m) => m.includes("express"))) {
+    techStack.database = "express";
+  } else if (allModules.some((m) => m.includes("fastify"))) {
+    techStack.database = "fastify";
+  } else if (allModules.some((m) => m.includes("nestjs"))) {
+    techStack.database = "nestjs";
+  }
+  if (allModules.some((m) => m.includes("testing") || m.includes("tdd"))) {
+    techStack.testing = "vitest";
+  }
+  if (allModules.some((m) => m.includes("vercel"))) {
+    techStack.deployment = "vercel";
+  }
+  return techStack;
+}
+
+// src/lib/templates/scanner.ts
+init_cjs_shims();
+var fs3 = __toESM(require("fs/promises"), 1);
+var path3 = __toESM(require("path"), 1);
+
+// src/constants/template-placeholders.ts
+init_cjs_shims();
+
+// src/lib/templates/config-replacer.ts
+init_cjs_shims();
+var fs4 = __toESM(require("fs/promises"), 1);
+var path4 = __toESM(require("path"), 1);
+var import_ora2 = __toESM(require("ora"), 1);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BUNDLES,
+  DEPENDENCIES,
+  MCP_SERVERS,
+  PERMISSION_PRESETS,
+  PLACEHOLDERS,
+  buildTemplateContext,
+  createDefaultConfig,
+  detectProject,
+  getAllBundles,
+  getBundleById,
+  hasConfig,
+  installModules,
+  loadRegistry,
+  mergeBundleSelection,
+  processTemplates,
+  readConfig,
+  replacePlaceholders,
+  resolveBundle,
+  resolveBundles,
+  resolveModules,
+  writeConfig
+});
+//# sourceMappingURL=index.cjs.map