safeword 0.8.7 → 0.8.9

package/dist/{chunk-34PU3QZI.js → chunk-CLSGXTOL.js}

@@ -4,30 +4,30 @@ import {
 
 // src/utils/fs.ts
 import {
+  chmodSync,
   existsSync,
   mkdirSync,
+  readdirSync,
   readFileSync,
-  writeFileSync,
-  rmSync,
   rmdirSync,
-  readdirSync,
-  chmodSync
+  rmSync,
+  writeFileSync
 } from "fs";
-import { join, dirname } from "path";
+import nodePath from "path";
 import { fileURLToPath } from "url";
-var __dirname = dirname(fileURLToPath(import.meta.url));
-function getTemplatesDir() {
+var __dirname = nodePath.dirname(fileURLToPath(import.meta.url));
+function getTemplatesDirectory() {
   const knownTemplateFile = "SAFEWORD.md";
   const candidates = [
-    join(__dirname, "..", "templates"),
+    nodePath.join(__dirname, "..", "templates"),
     // From dist/ (flat bundled)
-    join(__dirname, "..", "..", "templates"),
+    nodePath.join(__dirname, "..", "..", "templates"),
     // From src/utils/ or dist/utils/
-    join(__dirname, "templates")
+    nodePath.join(__dirname, "templates")
     // Direct sibling (unlikely but safe)
   ];
   for (const candidate of candidates) {
-    if (existsSync(join(candidate, knownTemplateFile))) {
+    if (existsSync(nodePath.join(candidate, knownTemplateFile))) {
       return candidate;
     }
   }
@@ -36,20 +36,20 @@ function getTemplatesDir() {
 function exists(path) {
   return existsSync(path);
 }
-function ensureDir(path) {
+function ensureDirectory(path) {
   if (!existsSync(path)) {
     mkdirSync(path, { recursive: true });
   }
 }
 function readFile(path) {
-  return readFileSync(path, "utf-8");
+  return readFileSync(path, "utf8");
 }
 function readFileSafe(path) {
-  if (!existsSync(path)) return null;
-  return readFileSync(path, "utf-8");
+  if (!existsSync(path)) return void 0;
+  return readFileSync(path, "utf8");
 }
 function writeFile(path, content) {
-  ensureDir(dirname(path));
+  ensureDirectory(nodePath.dirname(path));
   writeFileSync(path, content);
 }
 function remove(path) {
@@ -70,146 +70,34 @@ function makeScriptsExecutable(dirPath) {
   if (!existsSync(dirPath)) return;
   for (const file of readdirSync(dirPath)) {
     if (file.endsWith(".sh")) {
-      chmodSync(join(dirPath, file), 493);
+      chmodSync(nodePath.join(dirPath, file), 493);
     }
   }
 }
 function readJson(path) {
   const content = readFileSafe(path);
-  if (!content) return null;
+  if (!content) return void 0;
   try {
     return JSON.parse(content);
   } catch {
-    return null;
+    return void 0;
   }
 }
 function writeJson(path, data) {
-  writeFile(path, JSON.stringify(data, null, 2) + "\n");
-}
-
-// src/utils/project-detector.ts
-import { readdirSync as readdirSync2 } from "fs";
-import { join as join2 } from "path";
-function hasShellScripts(cwd, maxDepth = 4) {
-  const excludeDirs = /* @__PURE__ */ new Set(["node_modules", ".git", ".safeword"]);
-  function scan(dir, depth) {
-    if (depth > maxDepth) return false;
-    try {
-      const entries = readdirSync2(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        if (entry.isFile() && entry.name.endsWith(".sh")) {
-          return true;
-        }
-        if (entry.isDirectory() && !excludeDirs.has(entry.name)) {
-          if (scan(join2(dir, entry.name), depth + 1)) {
-            return true;
-          }
-        }
-      }
-    } catch {
-    }
-    return false;
-  }
-  return scan(cwd, 0);
-}
-function detectProjectType(packageJson, cwd) {
-  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;
-  const hasShell = cwd ? hasShellScripts(cwd) : false;
-  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,
-    shell: hasShell
-  };
-}
-
-// 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.shell) plugins.push("prettier-plugin-sh");
-  if (projectType.tailwind) plugins.push("prettier-plugin-tailwindcss");
-  if (plugins.length > 0) {
-    config.plugins = plugins;
-  }
-  return JSON.stringify(config, null, 2) + "\n";
-}
-function getLintStagedConfig(projectType) {
-  const 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"]
-  };
-  if (projectType.shell) {
-    config["*.sh"] = ["shellcheck", "prettier --write"];
-  }
-  return config;
+  writeFile(path, `${JSON.stringify(data, void 0, 2)}
+`);
 }
 
 // src/templates/config.ts
-function getEslintConfig(options) {
-  return `/* eslint-disable import-x/no-unresolved, no-undef -- dynamic imports for optional framework plugins, console used in tryImport */
+function getEslintConfig() {
+  return `/* eslint-disable import-x/no-unresolved, no-undef -- dynamic imports for optional framework plugins */
 import { readFileSync } from "fs";
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
-import { defineConfig } from "eslint/config";
-import js from "@eslint/js";
-import { importX } from "eslint-plugin-import-x";
-import { createTypeScriptImportResolver } from "eslint-import-resolver-typescript";
-import sonarjs from "eslint-plugin-sonarjs";
-import sdl from "@microsoft/eslint-plugin-sdl";
-import playwright from "eslint-plugin-playwright";
-import unicorn from "eslint-plugin-unicorn";
+import safeword from "eslint-plugin-safeword";
 import eslintConfigPrettier from "eslint-config-prettier";
-${options.boundaries ? 'import boundariesConfig from "./.safeword/eslint-boundaries.config.mjs";' : ""}
 
 // Read package.json relative to this config file (not CWD)
-// This ensures correct detection in monorepos where lint-staged may run from subdirectories
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(join(__dirname, "package.json"), "utf8"));
 const deps = { ...pkg.dependencies, ...pkg.devDependencies };
@@ -236,148 +124,55 @@ 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)
+// Select appropriate safeword config based on detected framework
+// Order matters: most specific first
+let baseConfig;
+if (deps["next"]) {
+  baseConfig = safeword.configs.recommendedTypeScriptNext;
+} else if (deps["react"]) {
+  baseConfig = safeword.configs.recommendedTypeScriptReact;
+} else if (deps["astro"]) {
+  baseConfig = safeword.configs.astro;
+} else if (deps["typescript"] || deps["typescript-eslint"]) {
+  baseConfig = safeword.configs.recommendedTypeScript;
+} else {
+  baseConfig = safeword.configs.recommended;
+}
+
+// Start with ignores + safeword config
 const configs = [
   { ignores },
-  js.configs.recommended,
-  importX.flatConfigs.recommended,
-  {
-    settings: {
-      "import-x/resolver-next": [createTypeScriptImportResolver()],
-    },
-  },
-  sonarjs.configs.recommended,
-  ...sdl.configs.recommended,
-  unicorn.configs["flat/recommended"],
-  {
-    // Unicorn overrides for LLM-generated code
-    // Keep modern JS enforcement, disable overly pedantic rules
-    rules: {
-      "unicorn/prevent-abbreviations": "off", // ctx, dir, pkg, err are standard
-      "unicorn/no-null": "off", // null is valid JS
-      "unicorn/no-process-exit": "off", // CLI apps use process.exit
-      "unicorn/import-style": "off", // Named imports are fine
-      "unicorn/numeric-separators-style": "off", // Style preference
-      "unicorn/text-encoding-identifier-case": "off", // utf-8 vs utf8
-      "unicorn/switch-case-braces": "warn", // Good practice, not critical
-      "unicorn/catch-error-name": "warn", // Reasonable, auto-fixable
-      "unicorn/no-negated-condition": "off", // Sometimes clearer
-      "unicorn/no-array-reduce": "off", // Reduce is fine when readable
-      "unicorn/no-array-for-each": "off", // forEach is fine
-      "unicorn/prefer-module": "off", // CJS still valid
-    },
-  },
+  ...baseConfig,
 ];
 
-// TypeScript support (detected from package.json)
-// Uses type-aware rules if tsconfig.json exists, otherwise falls back to basic rules
-if (deps["typescript"] || deps["typescript-eslint"]) {
-  const tseslint = await tryImport("typescript-eslint", "TypeScript");
-  const { existsSync } = await import("fs");
-  const hasTsconfig = existsSync(join(__dirname, "tsconfig.json"));
-
-  configs.push(importX.flatConfigs.typescript);
-
-  if (hasTsconfig) {
-    // Type-aware linting (recommended + stylistic)
-    configs.push(...tseslint.default.configs.recommendedTypeChecked);
-    configs.push(...tseslint.default.configs.stylisticTypeChecked);
-    configs.push({
-      languageOptions: {
-        parserOptions: {
-          projectService: true,
-          tsconfigRootDir: __dirname,
-        },
-      },
-    });
-    // Disable type-checked rules for JS files (no type info available)
-    configs.push({
-      files: ["**/*.js", "**/*.mjs", "**/*.cjs"],
-      extends: [tseslint.default.configs.disableTypeChecked],
-    });
-  } else {
-    // Fall back to non-type-aware rules when no tsconfig exists
-    configs.push(...tseslint.default.configs.recommended);
-    configs.push(...tseslint.default.configs.stylistic);
-  }
-}
-
-// React/Next.js support
-if (deps["react"] || deps["next"]) {
-  const react = await tryImport("eslint-plugin-react", "React");
-  const reactHooks = await tryImport("eslint-plugin-react-hooks", "React");
-  const jsxA11y = await tryImport("eslint-plugin-jsx-a11y", "React");
-  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 tryImport("@next/eslint-plugin-next", "Next.js");
-  configs.push({
-    name: "nextjs",
-    plugins: { "@next/next": nextPlugin.default },
-    rules: nextPlugin.default.configs.recommended.rules,
-  });
+// Add test configs if testing frameworks detected
+if (deps["vitest"]) {
+  configs.push(...safeword.configs.vitest);
 }
-
-// Astro support
-if (deps["astro"]) {
-  const astro = await tryImport("eslint-plugin-astro", "Astro");
-  configs.push(...astro.default.configs.recommended);
+if (deps["playwright"] || deps["@playwright/test"]) {
+  configs.push(...safeword.configs.playwright);
 }
 
-// Vue support
+// Frameworks NOT in eslint-plugin-safeword (dynamic imports)
 if (deps["vue"] || deps["nuxt"]) {
   const vue = await tryImport("eslint-plugin-vue", "Vue");
   configs.push(...vue.default.configs["flat/recommended"]);
 }
 
-// Svelte support
 if (deps["svelte"] || deps["@sveltejs/kit"]) {
   const svelte = await tryImport("eslint-plugin-svelte", "Svelte");
   configs.push(...svelte.default.configs.recommended);
 }
 
-// Electron support
 if (deps["electron"]) {
   const electron = await tryImport("@electron-toolkit/eslint-config", "Electron");
   configs.push(electron.default);
 }
 
-// Vitest support (scoped to test files)
-if (deps["vitest"]) {
-  const vitest = await tryImport("@vitest/eslint-plugin", "Vitest");
-  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);
+export default configs;
 `;
 }
 var CURSOR_HOOKS = {
@@ -452,166 +247,50 @@ var SETTINGS_HOOKS = {
   ]
 };
 
-// src/utils/boundaries.ts
-import { join as join3 } from "path";
-import { readdirSync as readdirSync3 } from "fs";
-var ARCHITECTURE_LAYERS = [
-  // Layer 0: Pure types (no imports)
-  { layer: "types", dirs: ["types", "interfaces", "schemas"] },
-  // Layer 1: Utilities (only types)
-  { layer: "utils", dirs: ["utils", "helpers", "shared", "common", "core"] },
-  // Layer 2: Libraries (types, utils)
-  { layer: "lib", dirs: ["lib", "libraries"] },
-  // Layer 3: State & logic (types, utils, lib)
-  { layer: "hooks", dirs: ["hooks", "composables"] },
-  { layer: "services", dirs: ["services", "api", "stores", "state"] },
-  // Layer 4: UI components (all above)
-  { layer: "components", dirs: ["components", "ui"] },
-  // Layer 5: Features (all above)
-  { layer: "features", dirs: ["features", "modules", "domains"] },
-  // Layer 6: Entry points (can import everything)
-  { layer: "app", dirs: ["app", "pages", "views", "routes", "commands"] }
-];
-var HIERARCHY = {
-  types: [],
-  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"],
-  app: ["features", "components", "hooks", "services", "lib", "utils", "types"]
-};
-function findMonorepoPackages(projectDir) {
-  const packages = [];
-  const monorepoRoots = ["packages", "apps", "libs", "modules"];
-  for (const root of monorepoRoots) {
-    const rootPath = join3(projectDir, root);
-    if (exists(rootPath)) {
-      try {
-        const entries = readdirSync3(rootPath, { withFileTypes: true });
-        for (const entry of entries) {
-          if (entry.isDirectory() && !entry.name.startsWith(".")) {
-            packages.push(join3(root, entry.name));
-          }
-        }
-      } catch {
-      }
-    }
-  }
-  return packages;
-}
-function hasLayerForPrefix(elements, layer, pathPrefix) {
-  return elements.some((e) => e.layer === layer && e.pattern.startsWith(pathPrefix));
-}
-function scanSearchPath(projectDir, searchPath, pathPrefix, elements) {
-  for (const layerDef of ARCHITECTURE_LAYERS) {
-    for (const dirName of layerDef.dirs) {
-      const fullPath = join3(projectDir, searchPath, dirName);
-      if (exists(fullPath) && !hasLayerForPrefix(elements, layerDef.layer, pathPrefix)) {
-        elements.push({
-          layer: layerDef.layer,
-          pattern: `${pathPrefix}${dirName}/**`,
-          location: `${pathPrefix}${dirName}`
-        });
-      }
-    }
-  }
-}
-function scanForLayers(projectDir, basePath) {
-  const elements = [];
-  const prefix = basePath ? `${basePath}/` : "";
-  scanSearchPath(projectDir, join3(basePath, "src"), `${prefix}src/`, elements);
-  scanSearchPath(projectDir, basePath, prefix, elements);
-  return elements;
-}
-function detectArchitecture(projectDir) {
-  const elements = [];
-  const packages = findMonorepoPackages(projectDir);
-  const isMonorepo = packages.length > 0;
-  if (isMonorepo) {
-    for (const pkg of packages) {
-      elements.push(...scanForLayers(projectDir, pkg));
-    }
+// 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: "all",
+    printWidth: 100,
+    endOfLine: "lf",
+    useTabs: false,
+    bracketSpacing: true,
+    arrowParens: "avoid"
+  };
+  const plugins = [];
+  if (projectType.astro) plugins.push("prettier-plugin-astro");
+  if (projectType.svelte) plugins.push("prettier-plugin-svelte");
+  if (projectType.shell) plugins.push("prettier-plugin-sh");
+  if (projectType.tailwind) plugins.push("prettier-plugin-tailwindcss");
+  if (plugins.length > 0) {
+    config.plugins = plugins;
   }
-  elements.push(...scanForLayers(projectDir, ""));
-  const seen = /* @__PURE__ */ new Set();
-  const uniqueElements = elements.filter((e) => {
-    if (seen.has(e.pattern)) return false;
-    seen.add(e.pattern);
-    return true;
-  });
-  return { elements: uniqueElements, isMonorepo };
-}
-function formatElement(el) {
-  return `      { type: '${el.layer}', pattern: '${el.pattern}', mode: 'full' }`;
-}
-function formatAllowedImports(allowed) {
-  return allowed.map((d) => `'${d}'`).join(", ");
+  return `${JSON.stringify(config, void 0, 2)}
+`;
 }
-function generateRule(layer, detectedLayers) {
-  const allowedLayers = HIERARCHY[layer];
-  if (allowedLayers.length === 0) return null;
-  const allowed = allowedLayers.filter((dep) => detectedLayers.has(dep));
-  if (allowed.length === 0) return null;
-  return `        { from: ['${layer}'], allow: [${formatAllowedImports(allowed)}] }`;
+
+// src/utils/hooks.ts
+function isHookEntry(h) {
+  return typeof h === "object" && h !== void 0 && "hooks" in h && Array.isArray(h.hooks);
 }
-function buildDetectedInfo(arch) {
-  if (arch.elements.length === 0) {
-    return "No architecture directories detected yet - add types/, utils/, components/, etc.";
-  }
-  const locations = arch.elements.map((e) => e.location).join(", ");
-  const monorepoNote = arch.isMonorepo ? " (monorepo)" : "";
-  return `Detected: ${locations}${monorepoNote}`;
+function isSafewordHook(h) {
+  if (!isHookEntry(h)) return false;
+  return h.hooks.some((cmd) => typeof cmd.command === "string" && cmd.command.includes(".safeword"));
 }
-function generateBoundariesConfig(arch) {
-  const hasElements = arch.elements.length > 0;
-  const elementsContent = arch.elements.map((el) => formatElement(el)).join(",\n");
-  const detectedLayers = new Set(arch.elements.map((e) => e.layer));
-  const rules = [...detectedLayers].map((layer) => generateRule(layer, detectedLayers)).filter((rule) => rule !== null);
-  const rulesContent = rules.join(",\n");
-  const detectedInfo = buildDetectedInfo(arch);
-  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: {${hasElements ? `
-    '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
-  },
-};
-`;
+function filterOutSafewordHooks(hooks) {
+  return hooks.filter((h) => !isSafewordHook(h));
 }
 
 // src/utils/install.ts
-var HUSKY_PRE_COMMIT_CONTENT = "npx safeword sync --quiet --stage\nnpx lint-staged\n";
 var MCP_SERVERS = {
   context7: {
     command: "npx",
@@ -623,18 +302,6 @@ var MCP_SERVERS = {
   }
 };
 
-// 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
 function isEslintPackage(pkg) {
   return pkg.startsWith("eslint") || pkg.startsWith("@eslint/") || pkg.startsWith("@microsoft/eslint") || pkg.startsWith("@next/eslint") || pkg.startsWith("@vitest/eslint") || pkg.startsWith("@electron-toolkit/eslint") || pkg === "typescript-eslint";
@@ -664,7 +331,6 @@ var SAFEWORD_SCHEMA = {
     ".safeword/planning/issues",
     ".safeword/planning/plans",
     ".safeword/scripts",
-    ".husky",
     ".cursor",
     ".cursor/rules",
     ".cursor/commands"
@@ -685,16 +351,47 @@ var SAFEWORD_SCHEMA = {
     ".safeword/guides/development-workflow.md",
     ".safeword/guides/tdd-best-practices.md",
     ".safeword/guides/user-story-guide.md",
-    ".safeword/guides/test-definitions-guide.md"
+    ".safeword/guides/test-definitions-guide.md",
+    // Boundaries config now project-specific (v0.9.0)
+    ".safeword/eslint-boundaries.config.mjs"
+  ],
+  // Packages to uninstall on upgrade (consolidated into eslint-plugin-safeword v0.9.0)
+  deprecatedPackages: [
+    // Individual ESLint plugins now bundled in eslint-plugin-safeword
+    "@eslint/js",
+    "eslint-plugin-import-x",
+    "eslint-import-resolver-typescript",
+    "eslint-plugin-sonarjs",
+    "eslint-plugin-unicorn",
+    "eslint-plugin-boundaries",
+    "eslint-plugin-playwright",
+    "eslint-plugin-promise",
+    "eslint-plugin-regexp",
+    "eslint-plugin-jsdoc",
+    "eslint-plugin-simple-import-sort",
+    "eslint-plugin-security",
+    // Conditional ESLint plugins now in safeword
+    "typescript-eslint",
+    "eslint-plugin-react",
+    "eslint-plugin-react-hooks",
+    "eslint-plugin-jsx-a11y",
+    "@next/eslint-plugin-next",
+    "eslint-plugin-astro",
+    "@vitest/eslint-plugin",
+    // Pre-commit hooks no longer managed by safeword
+    "husky",
+    "lint-staged"
+  ],
+  // Directories to delete on upgrade (no longer managed by safeword)
+  deprecatedDirs: [
+    ".husky"
+    // Pre-commit hooks no longer managed by safeword
   ],
   // 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" },
@@ -741,11 +438,12 @@ var SAFEWORD_SCHEMA = {
     // Prompts (2 files)
     ".safeword/prompts/architecture.md": { template: "prompts/architecture.md" },
     ".safeword/prompts/quality-review.md": { template: "prompts/quality-review.md" },
-    // Scripts (3 files)
+    // Scripts (4 files)
     ".safeword/scripts/bisect-test-pollution.sh": { template: "scripts/bisect-test-pollution.sh" },
     ".safeword/scripts/bisect-zombie-processes.sh": {
       template: "scripts/bisect-zombie-processes.sh"
     },
+    ".safeword/scripts/cleanup-zombies.sh": { template: "scripts/cleanup-zombies.sh" },
     ".safeword/scripts/lint-md.sh": { template: "scripts/lint-md.sh" },
     // Claude skills and commands (9 files)
     ".claude/skills/safeword-brainstorming/SKILL.md": {
@@ -767,10 +465,9 @@ var SAFEWORD_SCHEMA = {
       template: "skills/safeword-writing-plans/SKILL.md"
     },
     ".claude/commands/architecture.md": { template: "commands/architecture.md" },
+    ".claude/commands/cleanup-zombies.md": { template: "commands/cleanup-zombies.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 },
     // Cursor rules (7 files)
     ".cursor/rules/safeword-core.mdc": { template: "cursor/rules/safeword-core.mdc" },
     ".cursor/rules/safeword-brainstorming.mdc": {
@@ -791,10 +488,11 @@ var SAFEWORD_SCHEMA = {
     ".cursor/rules/safeword-writing-plans.mdc": {
       template: "cursor/rules/safeword-writing-plans.mdc"
     },
-    // Cursor commands (3 files - same as Claude)
+    // Cursor commands (4 files - same as Claude)
+    ".cursor/commands/architecture.md": { template: "commands/architecture.md" },
+    ".cursor/commands/cleanup-zombies.md": { template: "commands/cleanup-zombies.md" },
     ".cursor/commands/lint.md": { template: "commands/lint.md" },
     ".cursor/commands/quality-review.md": { template: "commands/quality-review.md" },
-    ".cursor/commands/architecture.md": { template: "commands/architecture.md" },
     // Cursor hooks adapters (2 files)
     ".safeword/hooks/cursor/after-file-edit.sh": { template: "hooks/cursor/after-file-edit.sh" },
     ".safeword/hooks/cursor/stop.sh": { template: "hooks/cursor/stop.sh" }
@@ -802,10 +500,35 @@ var SAFEWORD_SCHEMA = {
   // Files created if missing, updated only if content matches current template
   managedFiles: {
     "eslint.config.mjs": {
-      generator: () => getEslintConfig({ boundaries: true })
+      generator: () => getEslintConfig()
     },
     ".prettierrc": { generator: (ctx) => getPrettierConfig(ctx.projectType) },
-    ".markdownlint-cli2.jsonc": { template: "markdownlint-cli2.jsonc" }
+    ".markdownlint-cli2.jsonc": { template: "markdownlint-cli2.jsonc" },
+    // Minimal tsconfig for ESLint type-checked linting (only if missing)
+    "tsconfig.json": {
+      generator: (ctx) => {
+        if (!ctx.developmentDeps.typescript && !ctx.developmentDeps["typescript-eslint"]) {
+          return "";
+        }
+        return JSON.stringify(
+          {
+            compilerOptions: {
+              target: "ES2022",
+              module: "NodeNext",
+              moduleResolution: "NodeNext",
+              strict: true,
+              esModuleInterop: true,
+              skipLibCheck: true,
+              noEmit: true
+            },
+            include: ["**/*.ts", "**/*.tsx"],
+            exclude: ["node_modules", "dist", "build"]
+          },
+          void 0,
+          2
+        );
+      }
+    }
   },
   // JSON files where we merge specific keys
   jsonMerges: {
@@ -815,23 +538,20 @@ var SAFEWORD_SCHEMA = {
         "scripts.lint:md",
         "scripts.format",
         "scripts.format:check",
-        "scripts.knip",
-        "scripts.prepare",
-        "lint-staged"
+        "scripts.knip"
       ],
       conditionalKeys: {
         publishableLibrary: ["scripts.publint"],
         shell: ["scripts.lint:sh"]
       },
       merge: (existing, ctx) => {
-        const scripts = existing.scripts ?? {};
+        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";
         }
@@ -839,9 +559,6 @@ var SAFEWORD_SCHEMA = {
           scripts["lint:sh"] = "shellcheck **/*.sh";
         }
         result.scripts = scripts;
-        if (!existing["lint-staged"]) {
-          result["lint-staged"] = getLintStagedConfig(ctx.projectType);
-        }
         return result;
       },
       unmerge: (existing) => {
@@ -851,14 +568,12 @@ var SAFEWORD_SCHEMA = {
         delete scripts["lint:sh"];
         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;
       }
     },
@@ -995,42 +710,98 @@ var SAFEWORD_SCHEMA = {
   // NPM packages to install
   packages: {
     base: [
+      // Core tools
       "eslint",
       "prettier",
-      "@eslint/js",
-      "eslint-plugin-import-x",
-      "eslint-import-resolver-typescript",
-      "eslint-plugin-sonarjs",
-      "eslint-plugin-unicorn",
-      "eslint-plugin-boundaries",
-      "eslint-plugin-playwright",
-      "@microsoft/eslint-plugin-sdl",
       "eslint-config-prettier",
+      // Safeword plugin (bundles all ESLint plugins)
+      "eslint-plugin-safeword",
+      // Non-ESLint tools
       "markdownlint-cli2",
-      "knip",
-      "husky",
-      "lint-staged"
+      "knip"
     ],
     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"],
+      // Frameworks NOT in eslint-plugin-safeword
       vue: ["eslint-plugin-vue"],
       svelte: ["eslint-plugin-svelte", "prettier-plugin-svelte"],
       electron: ["@electron-toolkit/eslint-config"],
-      vitest: ["@vitest/eslint-plugin"],
+      // Prettier plugins
+      astro: ["prettier-plugin-astro"],
       tailwind: ["prettier-plugin-tailwindcss"],
+      // Non-ESLint tools
       publishableLibrary: ["publint"],
       shell: ["shellcheck", "prettier-plugin-sh"]
     }
   }
 };
 
+// src/utils/project-detector.ts
+import { readdirSync as readdirSync2 } from "fs";
+import nodePath2 from "path";
+function hasShellScripts(cwd, maxDepth = 4) {
+  const excludeDirectories = /* @__PURE__ */ new Set(["node_modules", ".git", ".safeword"]);
+  function scan(dir, depth) {
+    if (depth > maxDepth) return false;
+    try {
+      const entries = readdirSync2(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isFile() && entry.name.endsWith(".sh")) {
+          return true;
+        }
+        if (entry.isDirectory() && !excludeDirectories.has(entry.name) && scan(nodePath2.join(dir, entry.name), depth + 1)) {
+          return true;
+        }
+      }
+    } catch {
+    }
+    return false;
+  }
+  return scan(cwd, 0);
+}
+function detectProjectType(packageJson, cwd) {
+  const deps = packageJson.dependencies || {};
+  const developmentDeps = packageJson.devDependencies || {};
+  const allDeps = { ...deps, ...developmentDeps };
+  const hasTypescript = "typescript" in allDeps;
+  const hasReact = "react" in deps || "react" in developmentDeps;
+  const hasNextJs = "next" in deps;
+  const hasAstro = "astro" in deps || "astro" in developmentDeps;
+  const hasVue = "vue" in deps || "vue" in developmentDeps;
+  const hasNuxt = "nuxt" in deps;
+  const hasSvelte = "svelte" in deps || "svelte" in developmentDeps;
+  const hasSvelteKit = "@sveltejs/kit" in deps || "@sveltejs/kit" in developmentDeps;
+  const hasElectron = "electron" in deps || "electron" in developmentDeps;
+  const hasVitest = "vitest" in developmentDeps;
+  const hasPlaywright = "@playwright/test" in developmentDeps;
+  const hasTailwind = "tailwindcss" in allDeps;
+  const hasEntryPoints = !!(packageJson.main || packageJson.module || packageJson.exports);
+  const isPublishable = hasEntryPoints && packageJson.private !== true;
+  const hasShell = cwd ? hasShellScripts(cwd) : false;
+  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,
+    shell: hasShell
+  };
+}
+
 export {
-  getTemplatesDir,
+  getTemplatesDirectory,
   exists,
-  ensureDir,
+  ensureDirectory,
   readFile,
   readFileSafe,
   writeFile,
@@ -1039,9 +810,9 @@ export {
   makeScriptsExecutable,
   readJson,
   writeJson,
-  detectProjectType,
   getBaseEslintPackages,
   getConditionalEslintPackages,
-  SAFEWORD_SCHEMA
+  SAFEWORD_SCHEMA,
+  detectProjectType
 };
-//# sourceMappingURL=chunk-34PU3QZI.js.map
+//# sourceMappingURL=chunk-CLSGXTOL.js.map