safeword 0.6.3 → 0.6.5

package/dist/chunk-ZS3Z3Q37.js

@@ -0,0 +1,729 @@
+import {
+  VERSION
+} from "./chunk-ORQHKDT2.js";
+
+// src/utils/fs.ts
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  rmSync,
+  rmdirSync,
+  readdirSync,
+  chmodSync
+} from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+function getTemplatesDir() {
+  const knownTemplateFile = "SAFEWORD.md";
+  const candidates = [
+    join(__dirname, "..", "templates"),
+    // From dist/ (flat bundled)
+    join(__dirname, "..", "..", "templates"),
+    // From src/utils/ or dist/utils/
+    join(__dirname, "templates")
+    // Direct sibling (unlikely but safe)
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(join(candidate, knownTemplateFile))) {
+      return candidate;
+    }
+  }
+  throw new Error("Templates directory not found");
+}
+function exists(path) {
+  return existsSync(path);
+}
+function ensureDir(path) {
+  if (!existsSync(path)) {
+    mkdirSync(path, { recursive: true });
+  }
+}
+function readFile(path) {
+  return readFileSync(path, "utf-8");
+}
+function readFileSafe(path) {
+  if (!existsSync(path)) return null;
+  return readFileSync(path, "utf-8");
+}
+function writeFile(path, content) {
+  ensureDir(dirname(path));
+  writeFileSync(path, content);
+}
+function remove(path) {
+  if (existsSync(path)) {
+    rmSync(path, { recursive: true, force: true });
+  }
+}
+function removeIfEmpty(path) {
+  if (!existsSync(path)) return false;
+  try {
+    rmdirSync(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function makeScriptsExecutable(dirPath) {
+  if (!existsSync(dirPath)) return;
+  for (const file of readdirSync(dirPath)) {
+    if (file.endsWith(".sh")) {
+      chmodSync(join(dirPath, file), 493);
+    }
+  }
+}
+function readJson(path) {
+  const content = readFileSafe(path);
+  if (!content) return null;
+  try {
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function writeJson(path, data) {
+  writeFile(path, JSON.stringify(data, null, 2) + "\n");
+}
+
+// src/utils/project-detector.ts
+function detectProjectType(packageJson) {
+  const deps = packageJson.dependencies || {};
+  const devDeps = packageJson.devDependencies || {};
+  const allDeps = { ...deps, ...devDeps };
+  const hasTypescript = "typescript" in allDeps;
+  const hasReact = "react" in deps || "react" in devDeps;
+  const hasNextJs = "next" in deps;
+  const hasAstro = "astro" in deps || "astro" in devDeps;
+  const hasVue = "vue" in deps || "vue" in devDeps;
+  const hasNuxt = "nuxt" in deps;
+  const hasSvelte = "svelte" in deps || "svelte" in devDeps;
+  const hasSvelteKit = "@sveltejs/kit" in deps || "@sveltejs/kit" in devDeps;
+  const hasElectron = "electron" in deps || "electron" in devDeps;
+  const hasVitest = "vitest" in devDeps;
+  const hasPlaywright = "@playwright/test" in devDeps;
+  const hasTailwind = "tailwindcss" in allDeps;
+  const hasEntryPoints = !!(packageJson.main || packageJson.module || packageJson.exports);
+  const isPublishable = hasEntryPoints && packageJson.private !== true;
+  return {
+    typescript: hasTypescript,
+    react: hasReact || hasNextJs,
+    // Next.js implies React
+    nextjs: hasNextJs,
+    astro: hasAstro,
+    vue: hasVue || hasNuxt,
+    // Nuxt implies Vue
+    nuxt: hasNuxt,
+    svelte: hasSvelte || hasSvelteKit,
+    // SvelteKit implies Svelte
+    sveltekit: hasSvelteKit,
+    electron: hasElectron,
+    vitest: hasVitest,
+    playwright: hasPlaywright,
+    tailwind: hasTailwind,
+    publishableLibrary: isPublishable
+  };
+}
+
+// src/templates/content.ts
+var AGENTS_MD_LINK = `**\u26A0\uFE0F ALWAYS READ FIRST: @./.safeword/SAFEWORD.md**
+
+The SAFEWORD.md file contains core development patterns, workflows, and conventions.
+Read it BEFORE working on any task in this project.
+
+---`;
+function getPrettierConfig(projectType) {
+  const config = {
+    semi: true,
+    singleQuote: true,
+    tabWidth: 2,
+    trailingComma: "es5",
+    printWidth: 100,
+    endOfLine: "lf"
+  };
+  const plugins = [];
+  if (projectType.astro) plugins.push("prettier-plugin-astro");
+  if (projectType.svelte) plugins.push("prettier-plugin-svelte");
+  if (projectType.tailwind) plugins.push("prettier-plugin-tailwindcss");
+  if (plugins.length > 0) {
+    config.plugins = plugins;
+  }
+  return JSON.stringify(config, null, 2) + "\n";
+}
+var LINT_STAGED_CONFIG = {
+  "*.{js,jsx,ts,tsx,mjs,mts,cjs,cts}": ["eslint --fix", "prettier --write"],
+  "*.{vue,svelte,astro}": ["eslint --fix", "prettier --write"],
+  "*.{json,css,scss,html,yaml,yml,graphql}": ["prettier --write"],
+  "*.md": ["markdownlint-cli2 --fix", "prettier --write"]
+};
+
+// src/templates/config.ts
+function getEslintConfig(options) {
+  return `import { readFileSync } from "fs";
+import { defineConfig } from "eslint/config";
+import js from "@eslint/js";
+import { importX } from "eslint-plugin-import-x";
+import sonarjs from "eslint-plugin-sonarjs";
+import sdl from "@microsoft/eslint-plugin-sdl";
+import playwright from "eslint-plugin-playwright";
+import eslintConfigPrettier from "eslint-config-prettier";
+${options.boundaries ? 'import boundariesConfig from "./.safeword/eslint-boundaries.config.mjs";' : ""}
+
+// Read package.json to detect frameworks at runtime
+const pkg = JSON.parse(readFileSync("./package.json", "utf8"));
+const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+// Build dynamic ignores based on detected frameworks
+const ignores = ["node_modules/", "dist/", "build/", "coverage/"];
+if (deps["next"]) ignores.push(".next/");
+if (deps["astro"]) ignores.push(".astro/");
+if (deps["vue"] || deps["nuxt"]) ignores.push(".nuxt/");
+if (deps["svelte"] || deps["@sveltejs/kit"]) ignores.push(".svelte-kit/");
+
+// Start with base configs (always loaded)
+const configs = [
+  { ignores },
+  js.configs.recommended,
+  importX.flatConfigs.recommended,
+  sonarjs.configs.recommended,
+  ...sdl.configs.recommended,
+];
+
+// TypeScript support (detected from package.json)
+if (deps["typescript"]) {
+  const tseslint = await import("typescript-eslint");
+  configs.push(importX.flatConfigs.typescript);
+  configs.push(...tseslint.default.configs.recommended);
+}
+
+// React/Next.js support
+if (deps["react"] || deps["next"]) {
+  const react = await import("eslint-plugin-react");
+  const reactHooks = await import("eslint-plugin-react-hooks");
+  const jsxA11y = await import("eslint-plugin-jsx-a11y");
+  configs.push(react.default.configs.flat.recommended);
+  configs.push(react.default.configs.flat["jsx-runtime"]);
+  configs.push({
+    name: "react-hooks",
+    plugins: { "react-hooks": reactHooks.default },
+    rules: reactHooks.default.configs.recommended.rules,
+  });
+  configs.push(jsxA11y.default.flatConfigs.recommended);
+}
+
+// Next.js plugin
+if (deps["next"]) {
+  const nextPlugin = await import("@next/eslint-plugin-next");
+  configs.push({
+    name: "nextjs",
+    plugins: { "@next/next": nextPlugin.default },
+    rules: nextPlugin.default.configs.recommended.rules,
+  });
+}
+
+// Astro support
+if (deps["astro"]) {
+  const astro = await import("eslint-plugin-astro");
+  configs.push(...astro.default.configs.recommended);
+}
+
+// Vue support
+if (deps["vue"] || deps["nuxt"]) {
+  const vue = await import("eslint-plugin-vue");
+  configs.push(...vue.default.configs["flat/recommended"]);
+}
+
+// Svelte support
+if (deps["svelte"] || deps["@sveltejs/kit"]) {
+  const svelte = await import("eslint-plugin-svelte");
+  configs.push(...svelte.default.configs.recommended);
+}
+
+// Electron support
+if (deps["electron"]) {
+  const electron = await import("@electron-toolkit/eslint-config");
+  configs.push(electron.default);
+}
+
+// Vitest support (scoped to test files)
+if (deps["vitest"]) {
+  const vitest = await import("@vitest/eslint-plugin");
+  configs.push({
+    name: "vitest",
+    files: ["**/*.test.{js,ts,jsx,tsx}", "**/*.spec.{js,ts,jsx,tsx}", "**/tests/**"],
+    plugins: { vitest: vitest.default },
+    languageOptions: {
+      globals: { ...vitest.default.environments.env.globals },
+    },
+    rules: { ...vitest.default.configs.recommended.rules },
+  });
+}
+
+// Playwright for e2e tests (always included - safeword sets up Playwright)
+configs.push({
+  name: "playwright",
+  files: ["**/e2e/**", "**/*.e2e.{js,ts,jsx,tsx}", "**/playwright/**"],
+  ...playwright.configs["flat/recommended"],
+});
+
+// Architecture boundaries${options.boundaries ? "\nconfigs.push(boundariesConfig);" : ""}
+
+// eslint-config-prettier must be last to disable conflicting rules
+configs.push(eslintConfigPrettier);
+
+export default defineConfig(configs);
+`;
+}
+var SETTINGS_HOOKS = {
+  SessionStart: [
+    {
+      hooks: [
+        {
+          type: "command",
+          command: '"$CLAUDE_PROJECT_DIR"/.safeword/hooks/session-verify-agents.sh'
+        }
+      ]
+    },
+    {
+      hooks: [
+        {
+          type: "command",
+          command: '"$CLAUDE_PROJECT_DIR"/.safeword/hooks/session-version.sh'
+        }
+      ]
+    },
+    {
+      hooks: [
+        {
+          type: "command",
+          command: '"$CLAUDE_PROJECT_DIR"/.safeword/hooks/session-lint-check.sh'
+        }
+      ]
+    }
+  ],
+  UserPromptSubmit: [
+    {
+      hooks: [
+        {
+          type: "command",
+          command: '"$CLAUDE_PROJECT_DIR"/.safeword/hooks/prompt-timestamp.sh'
+        }
+      ]
+    },
+    {
+      hooks: [
+        {
+          type: "command",
+          command: '"$CLAUDE_PROJECT_DIR"/.safeword/hooks/prompt-questions.sh'
+        }
+      ]
+    }
+  ],
+  Stop: [
+    {
+      hooks: [
+        {
+          type: "command",
+          command: '"$CLAUDE_PROJECT_DIR"/.safeword/hooks/stop-quality.sh'
+        }
+      ]
+    }
+  ],
+  PostToolUse: [
+    {
+      matcher: "Write|Edit|MultiEdit|NotebookEdit",
+      hooks: [
+        {
+          type: "command",
+          command: '"$CLAUDE_PROJECT_DIR"/.safeword/hooks/post-tool-lint.sh'
+        }
+      ]
+    }
+  ]
+};
+
+// src/utils/boundaries.ts
+import { join as join2 } from "path";
+var ARCHITECTURE_DIRS = [
+  "types",
+  // Bottom: can be imported by everything
+  "utils",
+  "lib",
+  "hooks",
+  "services",
+  "components",
+  "features",
+  "modules",
+  "app"
+  // Top: can import everything
+];
+var HIERARCHY = {
+  types: [],
+  // types can't import anything (pure type definitions)
+  utils: ["types"],
+  lib: ["utils", "types"],
+  hooks: ["lib", "utils", "types"],
+  services: ["lib", "utils", "types"],
+  components: ["hooks", "services", "lib", "utils", "types"],
+  features: ["components", "hooks", "services", "lib", "utils", "types"],
+  modules: ["components", "hooks", "services", "lib", "utils", "types"],
+  app: ["features", "modules", "components", "hooks", "services", "lib", "utils", "types"]
+};
+function detectArchitecture(projectDir) {
+  const foundInSrc = [];
+  const foundAtRoot = [];
+  for (const dir of ARCHITECTURE_DIRS) {
+    if (exists(join2(projectDir, "src", dir))) {
+      foundInSrc.push(dir);
+    }
+    if (exists(join2(projectDir, dir))) {
+      foundAtRoot.push(dir);
+    }
+  }
+  const inSrc = foundInSrc.length >= foundAtRoot.length;
+  const found = inSrc ? foundInSrc : foundAtRoot;
+  return { directories: found, inSrc };
+}
+function generateBoundariesConfig(arch) {
+  const prefix = arch.inSrc ? "src/" : "";
+  const hasDirectories = arch.directories.length > 0;
+  const elements = arch.directories.map((dir) => `      { type: '${dir}', pattern: '${prefix}${dir}/**', mode: 'full' }`).join(",\n");
+  const rules = arch.directories.filter((dir) => HIERARCHY[dir].length > 0).map((dir) => {
+    const allowed = HIERARCHY[dir].filter((dep) => arch.directories.includes(dep));
+    if (allowed.length === 0) return null;
+    return `        { from: ['${dir}'], allow: [${allowed.map((d) => `'${d}'`).join(", ")}] }`;
+  }).filter(Boolean).join(",\n");
+  const detectedInfo = hasDirectories ? `Detected directories: ${arch.directories.join(", ")} (${arch.inSrc ? "in src/" : "at root"})` : "No architecture directories detected yet - add types/, utils/, components/, etc.";
+  const elementsContent = elements || "";
+  const rulesContent = rules || "";
+  return `/**
+ * Architecture Boundaries Configuration (AUTO-GENERATED)
+ *
+ * ${detectedInfo}
+ *
+ * This enforces import boundaries between architectural layers:
+ * - Lower layers (types, utils) cannot import from higher layers (components, features)
+ * - Uses 'warn' severity - informative, not blocking
+ *
+ * Recognized directories (in hierarchy order):
+ *   types \u2192 utils \u2192 lib \u2192 hooks/services \u2192 components \u2192 features/modules \u2192 app
+ *
+ * To customize, override in your eslint.config.mjs:
+ *   rules: { 'boundaries/element-types': ['error', { ... }] }
+ */
+
+import boundaries from 'eslint-plugin-boundaries';
+
+export default {
+  plugins: { boundaries },
+  settings: {
+    'boundaries/elements': [
+${elementsContent}
+    ],
+  },
+  rules: {
+    'boundaries/element-types': ['warn', {
+      default: 'disallow',
+      rules: [
+${rulesContent}
+      ],
+    }],
+    'boundaries/no-unknown': 'off', // Allow files outside defined elements
+    'boundaries/no-unknown-files': 'off', // Allow non-matching files
+  },
+};
+`;
+}
+
+// src/utils/install.ts
+var HUSKY_PRE_COMMIT_CONTENT = "npx safeword sync --quiet --stage\nnpx lint-staged\n";
+var MCP_SERVERS = {
+  context7: {
+    command: "npx",
+    args: ["-y", "@upstash/context7-mcp@latest"]
+  },
+  playwright: {
+    command: "npx",
+    args: ["@playwright/mcp@latest"]
+  }
+};
+
+// src/utils/hooks.ts
+function isHookEntry(h) {
+  return typeof h === "object" && h !== null && "hooks" in h && Array.isArray(h.hooks);
+}
+function isSafewordHook(h) {
+  if (!isHookEntry(h)) return false;
+  return h.hooks.some(
+    (cmd) => typeof cmd.command === "string" && cmd.command.includes(".safeword")
+  );
+}
+function filterOutSafewordHooks(hooks) {
+  return hooks.filter((h) => !isSafewordHook(h));
+}
+
+// src/schema.ts
+var SAFEWORD_SCHEMA = {
+  version: VERSION,
+  // Directories fully owned by safeword (created on setup, deleted on reset)
+  ownedDirs: [
+    ".safeword",
+    ".safeword/hooks",
+    ".safeword/lib",
+    ".safeword/guides",
+    ".safeword/templates",
+    ".safeword/prompts",
+    ".safeword/planning",
+    ".safeword/planning/user-stories",
+    ".safeword/planning/test-definitions",
+    ".safeword/planning/design",
+    ".safeword/planning/issues",
+    ".husky"
+  ],
+  // Directories we add to but don't own (not deleted on reset)
+  sharedDirs: [".claude", ".claude/skills", ".claude/commands"],
+  // Created on setup but NOT deleted on reset (preserves user data)
+  preservedDirs: [".safeword/learnings", ".safeword/tickets", ".safeword/tickets/completed"],
+  // Files owned by safeword (overwritten on upgrade if content changed)
+  ownedFiles: {
+    // Core files
+    ".safeword/SAFEWORD.md": { template: "SAFEWORD.md" },
+    ".safeword/version": { content: () => VERSION },
+    ".safeword/eslint-boundaries.config.mjs": {
+      generator: (ctx) => generateBoundariesConfig(detectArchitecture(ctx.cwd))
+    },
+    // Hooks (7 files)
+    ".safeword/hooks/session-verify-agents.sh": { template: "hooks/session-verify-agents.sh" },
+    ".safeword/hooks/session-version.sh": { template: "hooks/session-version.sh" },
+    ".safeword/hooks/session-lint-check.sh": { template: "hooks/session-lint-check.sh" },
+    ".safeword/hooks/prompt-timestamp.sh": { template: "hooks/prompt-timestamp.sh" },
+    ".safeword/hooks/prompt-questions.sh": { template: "hooks/prompt-questions.sh" },
+    ".safeword/hooks/post-tool-lint.sh": { template: "hooks/post-tool-lint.sh" },
+    ".safeword/hooks/stop-quality.sh": { template: "hooks/stop-quality.sh" },
+    // Lib (2 files)
+    ".safeword/lib/common.sh": { template: "lib/common.sh" },
+    ".safeword/lib/jq-fallback.sh": { template: "lib/jq-fallback.sh" },
+    // Guides (13 files)
+    ".safeword/guides/architecture-guide.md": { template: "guides/architecture-guide.md" },
+    ".safeword/guides/cli-reference.md": { template: "guides/cli-reference.md" },
+    ".safeword/guides/code-philosophy.md": { template: "guides/code-philosophy.md" },
+    ".safeword/guides/context-files-guide.md": { template: "guides/context-files-guide.md" },
+    ".safeword/guides/data-architecture-guide.md": {
+      template: "guides/data-architecture-guide.md"
+    },
+    ".safeword/guides/design-doc-guide.md": { template: "guides/design-doc-guide.md" },
+    ".safeword/guides/development-workflow.md": { template: "guides/development-workflow.md" },
+    ".safeword/guides/learning-extraction.md": { template: "guides/learning-extraction.md" },
+    ".safeword/guides/llm-guide.md": { template: "guides/llm-guide.md" },
+    ".safeword/guides/tdd-best-practices.md": { template: "guides/tdd-best-practices.md" },
+    ".safeword/guides/test-definitions-guide.md": { template: "guides/test-definitions-guide.md" },
+    ".safeword/guides/user-story-guide.md": { template: "guides/user-story-guide.md" },
+    ".safeword/guides/zombie-process-cleanup.md": { template: "guides/zombie-process-cleanup.md" },
+    // Templates (5 files)
+    ".safeword/templates/architecture-template.md": {
+      template: "doc-templates/architecture-template.md"
+    },
+    ".safeword/templates/design-doc-template.md": {
+      template: "doc-templates/design-doc-template.md"
+    },
+    ".safeword/templates/test-definitions-feature.md": {
+      template: "doc-templates/test-definitions-feature.md"
+    },
+    ".safeword/templates/ticket-template.md": { template: "doc-templates/ticket-template.md" },
+    ".safeword/templates/user-stories-template.md": {
+      template: "doc-templates/user-stories-template.md"
+    },
+    // Prompts (2 files)
+    ".safeword/prompts/architecture.md": { template: "prompts/architecture.md" },
+    ".safeword/prompts/quality-review.md": { template: "prompts/quality-review.md" },
+    // Claude skills and commands (4 files)
+    ".claude/skills/safeword-quality-reviewer/SKILL.md": {
+      template: "skills/safeword-quality-reviewer/SKILL.md"
+    },
+    ".claude/commands/architecture.md": { template: "commands/architecture.md" },
+    ".claude/commands/lint.md": { template: "commands/lint.md" },
+    ".claude/commands/quality-review.md": { template: "commands/quality-review.md" },
+    // Husky (1 file)
+    ".husky/pre-commit": { content: HUSKY_PRE_COMMIT_CONTENT }
+  },
+  // Files created if missing, updated only if content matches current template
+  managedFiles: {
+    "eslint.config.mjs": {
+      generator: () => getEslintConfig({ boundaries: true })
+    },
+    ".prettierrc": { generator: (ctx) => getPrettierConfig(ctx.projectType) },
+    ".markdownlint-cli2.jsonc": { template: "markdownlint-cli2.jsonc" }
+  },
+  // JSON files where we merge specific keys
+  jsonMerges: {
+    "package.json": {
+      keys: [
+        "scripts.lint",
+        "scripts.lint:md",
+        "scripts.format",
+        "scripts.format:check",
+        "scripts.knip",
+        "scripts.prepare",
+        "lint-staged"
+      ],
+      conditionalKeys: {
+        publishableLibrary: ["scripts.publint"]
+      },
+      merge: (existing, ctx) => {
+        const scripts = existing.scripts ?? {};
+        const result = { ...existing };
+        if (!scripts.lint) scripts.lint = "eslint .";
+        if (!scripts["lint:md"]) scripts["lint:md"] = 'markdownlint-cli2 "**/*.md" "#node_modules"';
+        if (!scripts.format) scripts.format = "prettier --write .";
+        if (!scripts["format:check"]) scripts["format:check"] = "prettier --check .";
+        if (!scripts.knip) scripts.knip = "knip";
+        if (!scripts.prepare) scripts.prepare = "husky || true";
+        if (ctx.projectType.publishableLibrary && !scripts.publint) {
+          scripts.publint = "publint";
+        }
+        result.scripts = scripts;
+        if (!existing["lint-staged"]) {
+          result["lint-staged"] = LINT_STAGED_CONFIG;
+        }
+        return result;
+      },
+      unmerge: (existing) => {
+        const result = { ...existing };
+        const scripts = { ...existing.scripts ?? {} };
+        delete scripts["lint:md"];
+        delete scripts["format:check"];
+        delete scripts.knip;
+        delete scripts.prepare;
+        delete scripts.publint;
+        if (Object.keys(scripts).length > 0) {
+          result.scripts = scripts;
+        } else {
+          delete result.scripts;
+        }
+        delete result["lint-staged"];
+        return result;
+      }
+    },
+    ".claude/settings.json": {
+      keys: ["hooks"],
+      merge: (existing) => {
+        const existingHooks = existing.hooks ?? {};
+        const mergedHooks = { ...existingHooks };
+        for (const [event, newHooks] of Object.entries(SETTINGS_HOOKS)) {
+          const eventHooks = mergedHooks[event] ?? [];
+          const nonSafewordHooks = filterOutSafewordHooks(eventHooks);
+          mergedHooks[event] = [...nonSafewordHooks, ...newHooks];
+        }
+        return { ...existing, hooks: mergedHooks };
+      },
+      unmerge: (existing) => {
+        const existingHooks = existing.hooks ?? {};
+        const cleanedHooks = {};
+        for (const [event, eventHooks] of Object.entries(existingHooks)) {
+          const nonSafewordHooks = filterOutSafewordHooks(eventHooks);
+          if (nonSafewordHooks.length > 0) {
+            cleanedHooks[event] = nonSafewordHooks;
+          }
+        }
+        const result = { ...existing };
+        if (Object.keys(cleanedHooks).length > 0) {
+          result.hooks = cleanedHooks;
+        } else {
+          delete result.hooks;
+        }
+        return result;
+      }
+    },
+    ".mcp.json": {
+      keys: ["mcpServers.context7", "mcpServers.playwright"],
+      removeFileIfEmpty: true,
+      merge: (existing) => {
+        const mcpServers = existing.mcpServers ?? {};
+        return {
+          ...existing,
+          mcpServers: {
+            ...mcpServers,
+            context7: MCP_SERVERS.context7,
+            playwright: MCP_SERVERS.playwright
+          }
+        };
+      },
+      unmerge: (existing) => {
+        const result = { ...existing };
+        const mcpServers = { ...existing.mcpServers ?? {} };
+        delete mcpServers.context7;
+        delete mcpServers.playwright;
+        if (Object.keys(mcpServers).length > 0) {
+          result.mcpServers = mcpServers;
+        } else {
+          delete result.mcpServers;
+        }
+        return result;
+      }
+    }
+  },
+  // Text files where we patch specific content
+  textPatches: {
+    "AGENTS.md": {
+      operation: "prepend",
+      content: AGENTS_MD_LINK,
+      marker: "@./.safeword/SAFEWORD.md",
+      createIfMissing: true
+    },
+    "CLAUDE.md": {
+      operation: "prepend",
+      content: AGENTS_MD_LINK,
+      marker: "@./.safeword/SAFEWORD.md",
+      createIfMissing: false
+      // Only patch if exists, don't create (AGENTS.md is primary)
+    }
+  },
+  // NPM packages to install
+  packages: {
+    base: [
+      "eslint",
+      "prettier",
+      "@eslint/js",
+      "eslint-plugin-import-x",
+      "eslint-plugin-sonarjs",
+      "eslint-plugin-boundaries",
+      "eslint-plugin-playwright",
+      "@microsoft/eslint-plugin-sdl",
+      "eslint-config-prettier",
+      "markdownlint-cli2",
+      "knip",
+      "husky",
+      "lint-staged"
+    ],
+    conditional: {
+      typescript: ["typescript-eslint"],
+      react: ["eslint-plugin-react", "eslint-plugin-react-hooks", "eslint-plugin-jsx-a11y"],
+      nextjs: ["@next/eslint-plugin-next"],
+      astro: ["eslint-plugin-astro", "prettier-plugin-astro"],
+      vue: ["eslint-plugin-vue"],
+      svelte: ["eslint-plugin-svelte", "prettier-plugin-svelte"],
+      electron: ["@electron-toolkit/eslint-config"],
+      vitest: ["@vitest/eslint-plugin"],
+      tailwind: ["prettier-plugin-tailwindcss"],
+      publishableLibrary: ["publint"]
+    }
+  }
+};
+
+export {
+  getTemplatesDir,
+  exists,
+  ensureDir,
+  readFile,
+  readFileSafe,
+  writeFile,
+  remove,
+  removeIfEmpty,
+  makeScriptsExecutable,
+  readJson,
+  writeJson,
+  detectProjectType,
+  SAFEWORD_SCHEMA
+};
+//# sourceMappingURL=chunk-ZS3Z3Q37.js.map