safeword 0.10.1 → 0.11.1

package/dist/{chunk-H7PCVPAC.js → chunk-ZE6QJHZD.js}

@@ -1,96 +1,48 @@
 import {
   VERSION
 } from "./chunk-ORQHKDT2.js";
-
-// src/utils/fs.ts
 import {
-  chmodSync,
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  readFileSync,
-  rmdirSync,
-  rmSync,
-  writeFileSync
-} from "fs";
+  ensureDirectory,
+  exists,
+  getTemplatesDirectory,
+  makeScriptsExecutable,
+  readFile,
+  readFileSafe,
+  readJson,
+  remove,
+  removeIfEmpty,
+  writeFile,
+  writeJson
+} from "./chunk-DYLHQBW3.js";
+
+// src/reconcile.ts
 import nodePath from "path";
-import { fileURLToPath } from "url";
-var __dirname = nodePath.dirname(fileURLToPath(import.meta.url));
-function getTemplatesDirectory() {
-  const knownTemplateFile = "SAFEWORD.md";
-  const candidates = [
-    nodePath.join(__dirname, "..", "templates"),
-    // From dist/ (flat bundled)
-    nodePath.join(__dirname, "..", "..", "templates"),
-    // From src/utils/ or dist/utils/
-    nodePath.join(__dirname, "templates")
-    // Direct sibling (unlikely but safe)
-  ];
-  for (const candidate of candidates) {
-    if (existsSync(nodePath.join(candidate, knownTemplateFile))) {
-      return candidate;
+var HUSKY_DIR = ".husky";
+var PRETTIER_PACKAGES = /* @__PURE__ */ new Set([
+  "prettier",
+  "prettier-plugin-astro",
+  "prettier-plugin-tailwindcss",
+  "prettier-plugin-sh"
+]);
+function getConditionalPackages(conditionalPackages, projectType) {
+  const packages = [];
+  for (const [key, deps] of Object.entries(conditionalPackages)) {
+    if (key === "standard") {
+      if (!projectType.existingFormatter) {
+        packages.push(...deps);
+      }
+      continue;
     }
-  }
-  throw new Error("Templates directory not found");
-}
-function exists(path) {
-  return existsSync(path);
-}
-function ensureDirectory(path) {
-  if (!existsSync(path)) {
-    mkdirSync(path, { recursive: true });
-  }
-}
-function readFile(path) {
-  return readFileSync(path, "utf8");
-}
-function readFileSafe(path) {
-  if (!existsSync(path)) return void 0;
-  return readFileSync(path, "utf8");
-}
-function writeFile(path, content) {
-  ensureDirectory(nodePath.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(nodePath.join(dirPath, file), 493);
+    if (projectType[key]) {
+      if (projectType.existingFormatter) {
+        packages.push(...deps.filter((pkg) => !PRETTIER_PACKAGES.has(pkg)));
+      } else {
+        packages.push(...deps);
+      }
     }
   }
+  return packages;
 }
-function readJson(path) {
-  const content = readFileSafe(path);
-  if (!content) return void 0;
-  try {
-    return JSON.parse(content);
-  } catch {
-    return void 0;
-  }
-}
-function writeJson(path, data) {
-  writeFile(path, `${JSON.stringify(data, void 0, 2)}
-`);
-}
-
-// src/reconcile.ts
-import nodePath2 from "path";
-var HUSKY_DIR = ".husky";
 function shouldSkipForNonGit(path, isGitRepo2) {
   return path.startsWith(HUSKY_DIR) && !isGitRepo2;
 }
@@ -99,7 +51,7 @@ function planMissingDirectories(directories, cwd, isGitRepo2) {
   const created = [];
   for (const dir of directories) {
     if (shouldSkipForNonGit(dir, isGitRepo2)) continue;
-    if (!exists(nodePath2.join(cwd, dir))) {
+    if (!exists(nodePath.join(cwd, dir))) {
       actions.push({ type: "mkdir", path: dir });
       created.push(dir);
     }
@@ -110,7 +62,7 @@ function planTextPatches(patches, cwd, isGitRepo2) {
   const actions = [];
   for (const [filePath, definition] of Object.entries(patches)) {
     if (shouldSkipForNonGit(filePath, isGitRepo2)) continue;
-    const content = readFileSafe(nodePath2.join(cwd, filePath)) ?? "";
+    const content = readFileSafe(nodePath.join(cwd, filePath)) ?? "";
     if (!content.includes(definition.marker)) {
       actions.push({ type: "text-patch", path: filePath, definition });
     }
@@ -132,7 +84,7 @@ function planManagedFileWrites(files, ctx) {
   const actions = [];
   const created = [];
   for (const [filePath, definition] of Object.entries(files)) {
-    if (exists(nodePath2.join(ctx.cwd, filePath))) continue;
+    if (exists(nodePath.join(ctx.cwd, filePath))) continue;
     const content = resolveFileContent(definition, ctx);
     actions.push({ type: "write", path: filePath, content });
     created.push(filePath);
@@ -145,7 +97,7 @@ function planTextPatchesWithCreation(patches, ctx) {
   for (const [filePath, definition] of Object.entries(patches)) {
     if (shouldSkipForNonGit(filePath, ctx.isGitRepo)) continue;
     actions.push({ type: "text-patch", path: filePath, definition });
-    if (definition.createIfMissing && !exists(nodePath2.join(ctx.cwd, filePath))) {
+    if (definition.createIfMissing && !exists(nodePath.join(ctx.cwd, filePath))) {
       created.push(filePath);
     }
   }
@@ -155,7 +107,7 @@ function planExistingDirectoriesRemoval(directories, cwd) {
   const actions = [];
   const removed = [];
   for (const dir of directories) {
-    if (exists(nodePath2.join(cwd, dir))) {
+    if (exists(nodePath.join(cwd, dir))) {
       actions.push({ type: "rmdir", path: dir });
       removed.push(dir);
     }
@@ -166,7 +118,7 @@ function planExistingFilesRemoval(files, cwd) {
   const actions = [];
   const removed = [];
   for (const filePath of files) {
-    if (exists(nodePath2.join(cwd, filePath))) {
+    if (exists(nodePath.join(cwd, filePath))) {
       actions.push({ type: "rm", path: filePath });
       removed.push(filePath);
     }
@@ -210,7 +162,7 @@ function planDeprecatedFilesRemoval(deprecatedFiles, cwd) {
   const actions = [];
   const removed = [];
   for (const filePath of deprecatedFiles) {
-    if (exists(nodePath2.join(cwd, filePath))) {
+    if (exists(nodePath.join(cwd, filePath))) {
       actions.push({ type: "rm", path: filePath });
       removed.push(filePath);
     }
@@ -241,16 +193,21 @@ function computeInstallPlan(schema, ctx) {
   const actions = [];
   const wouldCreate = [];
   const allDirectories = [...schema.ownedDirs, ...schema.sharedDirs, ...schema.preservedDirs];
-  const dirs = planMissingDirectories(allDirectories, ctx.cwd, ctx.isGitRepo);
-  actions.push(...dirs.actions);
-  wouldCreate.push(...dirs.created);
+  const directories = planMissingDirectories(allDirectories, ctx.cwd, ctx.isGitRepo);
+  actions.push(...directories.actions);
+  wouldCreate.push(...directories.created);
   const owned = planOwnedFileWrites(schema.ownedFiles, ctx);
   actions.push(...owned.actions);
   wouldCreate.push(...owned.created);
   const managed = planManagedFileWrites(schema.managedFiles, ctx);
   actions.push(...managed.actions);
   wouldCreate.push(...managed.created);
-  const chmodPaths = [".safeword/hooks", ".safeword/hooks/cursor", ".safeword/lib", ".safeword/scripts"];
+  const chmodPaths = [
+    ".safeword/hooks",
+    ".safeword/hooks/cursor",
+    ".safeword/lib",
+    ".safeword/scripts"
+  ];
   if (ctx.isGitRepo) chmodPaths.push(HUSKY_DIR);
   actions.push({ type: "chmod", paths: chmodPaths });
   for (const [filePath, definition] of Object.entries(schema.jsonMerges)) {
@@ -259,8 +216,20 @@ function computeInstallPlan(schema, ctx) {
   const patches = planTextPatchesWithCreation(schema.textPatches, ctx);
   actions.push(...patches.actions);
   wouldCreate.push(...patches.created);
-  const packagesToInstall = computePackagesToInstall(schema, ctx.projectType, ctx.developmentDeps, ctx.isGitRepo);
-  return { actions, wouldCreate, wouldUpdate: [], wouldRemove: [], packagesToInstall, packagesToRemove: [] };
+  const packagesToInstall = computePackagesToInstall(
+    schema,
+    ctx.projectType,
+    ctx.developmentDeps,
+    ctx.isGitRepo
+  );
+  return {
+    actions,
+    wouldCreate,
+    wouldUpdate: [],
+    wouldRemove: [],
+    packagesToInstall,
+    packagesToRemove: []
+  };
 }
 function computeUpgradePlan(schema, ctx) {
   const actions = [];
@@ -272,7 +241,7 @@ function computeUpgradePlan(schema, ctx) {
   wouldCreate.push(...missingDirectories.created);
   for (const [filePath, definition] of Object.entries(schema.ownedFiles)) {
     if (shouldSkipForNonGit(filePath, ctx.isGitRepo)) continue;
-    const fullPath = nodePath2.join(ctx.cwd, filePath);
+    const fullPath = nodePath.join(ctx.cwd, filePath);
     const newContent = resolveFileContent(definition, ctx);
     if (!fileNeedsUpdate(fullPath, newContent)) continue;
     actions.push({ type: "write", path: filePath, content: newContent });
@@ -283,7 +252,7 @@ function computeUpgradePlan(schema, ctx) {
     }
   }
   for (const [filePath, definition] of Object.entries(schema.managedFiles)) {
-    const fullPath = nodePath2.join(ctx.cwd, filePath);
+    const fullPath = nodePath.join(ctx.cwd, filePath);
     const newContent = resolveFileContent(definition, ctx);
     if (!exists(fullPath)) {
       actions.push({ type: "write", path: filePath, content: newContent });
@@ -341,7 +310,7 @@ function computeUninstallPlan(schema, ctx, full) {
     actions.push({ type: "json-unmerge", path: filePath, definition });
   }
   for (const [filePath, definition] of Object.entries(schema.textPatches)) {
-    const fullPath = nodePath2.join(ctx.cwd, filePath);
+    const fullPath = nodePath.join(ctx.cwd, filePath);
     if (exists(fullPath)) {
       const content = readFileSafe(fullPath) ?? "";
       if (content.includes(definition.marker)) {
@@ -382,48 +351,57 @@ function executePlan(plan, ctx) {
 }
 function executeChmod(cwd, paths) {
   for (const path of paths) {
-    const fullPath = nodePath2.join(cwd, path);
+    const fullPath = nodePath.join(cwd, path);
     if (exists(fullPath)) makeScriptsExecutable(fullPath);
   }
 }
 function executeRmdir(cwd, path, result) {
-  if (removeIfEmpty(nodePath2.join(cwd, path))) result.removed.push(path);
+  if (removeIfEmpty(nodePath.join(cwd, path))) result.removed.push(path);
 }
 function executeAction(action, ctx, result) {
   switch (action.type) {
-    case "mkdir":
-      ensureDirectory(nodePath2.join(ctx.cwd, action.path));
+    case "mkdir": {
+      ensureDirectory(nodePath.join(ctx.cwd, action.path));
       result.created.push(action.path);
       break;
-    case "rmdir":
+    }
+    case "rmdir": {
       executeRmdir(ctx.cwd, action.path, result);
       break;
-    case "write":
+    }
+    case "write": {
       executeWrite(ctx.cwd, action.path, action.content, result);
       break;
-    case "rm":
-      remove(nodePath2.join(ctx.cwd, action.path));
+    }
+    case "rm": {
+      remove(nodePath.join(ctx.cwd, action.path));
       result.removed.push(action.path);
       break;
-    case "chmod":
+    }
+    case "chmod": {
       executeChmod(ctx.cwd, action.paths);
       break;
-    case "json-merge":
+    }
+    case "json-merge": {
       executeJsonMerge(ctx.cwd, action.path, action.definition, ctx);
       break;
-    case "json-unmerge":
+    }
+    case "json-unmerge": {
       executeJsonUnmerge(ctx.cwd, action.path, action.definition);
       break;
-    case "text-patch":
+    }
+    case "text-patch": {
       executeTextPatch(ctx.cwd, action.path, action.definition);
       break;
-    case "text-unpatch":
+    }
+    case "text-unpatch": {
       executeTextUnpatch(ctx.cwd, action.path, action.definition);
       break;
+    }
   }
 }
 function executeWrite(cwd, path, content, result) {
-  const fullPath = nodePath2.join(cwd, path);
+  const fullPath = nodePath.join(cwd, path);
   const existed = exists(fullPath);
   writeFile(fullPath, content);
   (existed ? result.updated : result.created).push(path);
@@ -431,7 +409,7 @@ function executeWrite(cwd, path, content, result) {
 function resolveFileContent(definition, ctx) {
   if (definition.template) {
     const templatesDirectory = getTemplatesDirectory();
-    return readFile(nodePath2.join(templatesDirectory, definition.template));
+    return readFile(nodePath.join(templatesDirectory, definition.template));
   }
   if (definition.content) {
     return typeof definition.content === "function" ? definition.content() : definition.content;
@@ -452,31 +430,25 @@ function computePackagesToInstall(schema, projectType, installedDevelopmentDeps,
   if (!isGitRepo2) {
     needed = needed.filter((pkg) => !GIT_ONLY_PACKAGES.has(pkg));
   }
-  for (const [key, deps] of Object.entries(schema.packages.conditional)) {
-    if (projectType[key]) {
-      needed.push(...deps);
-    }
-  }
+  needed.push(...getConditionalPackages(schema.packages.conditional, projectType));
   return needed.filter((pkg) => !(pkg in installedDevelopmentDeps));
 }
 function computePackagesToRemove(schema, projectType, installedDevelopmentDeps) {
-  const safewordPackages = [...schema.packages.base];
-  for (const [key, deps] of Object.entries(schema.packages.conditional)) {
-    if (projectType[key]) {
-      safewordPackages.push(...deps);
-    }
-  }
+  const safewordPackages = [
+    ...schema.packages.base,
+    ...getConditionalPackages(schema.packages.conditional, projectType)
+  ];
   return safewordPackages.filter((pkg) => pkg in installedDevelopmentDeps);
 }
 function executeJsonMerge(cwd, path, definition, ctx) {
-  const fullPath = nodePath2.join(cwd, path);
+  const fullPath = nodePath.join(cwd, path);
   const existing = readJson(fullPath) ?? {};
   const merged = definition.merge(existing, ctx);
   if (JSON.stringify(existing) === JSON.stringify(merged)) return;
   writeJson(fullPath, merged);
 }
 function executeJsonUnmerge(cwd, path, definition) {
-  const fullPath = nodePath2.join(cwd, path);
+  const fullPath = nodePath.join(cwd, path);
   if (!exists(fullPath)) return;
   const existing = readJson(fullPath);
   if (!existing) return;
@@ -491,14 +463,14 @@ function executeJsonUnmerge(cwd, path, definition) {
   writeJson(fullPath, unmerged);
 }
 function executeTextPatch(cwd, path, definition) {
-  const fullPath = nodePath2.join(cwd, path);
+  const fullPath = nodePath.join(cwd, path);
   let content = readFileSafe(fullPath) ?? "";
   if (content.includes(definition.marker)) return;
   content = definition.operation === "prepend" ? definition.content + content : content + definition.content;
   writeFile(fullPath, content);
 }
 function executeTextUnpatch(cwd, path, definition) {
-  const fullPath = nodePath2.join(cwd, path);
+  const fullPath = nodePath.join(cwd, path);
   const content = readFileSafe(fullPath);
   if (!content) return;
   let unpatched = content.replace(definition.content, "");
@@ -511,56 +483,74 @@ function executeTextUnpatch(cwd, path, definition) {
 }
 
 // src/templates/config.ts
-function getEslintConfig() {
-  return `import { readFileSync } from "fs";
-import { dirname, join } from "path";
-import { fileURLToPath } from "url";
+function getEslintConfig(hasExistingFormatter2 = false) {
+  if (hasExistingFormatter2) {
+    return getFormatterAgnosticEslintConfig();
+  }
+  return getStandardEslintConfig();
+}
+function getStandardEslintConfig() {
+  return `import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
 import safeword from "eslint-plugin-safeword";
 import eslintConfigPrettier from "eslint-config-prettier";
 
-// Read package.json relative to this config file (not CWD)
+const { detect, configs } = safeword;
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const pkg = JSON.parse(readFileSync(join(__dirname, "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/");
+const deps = detect.collectAllDeps(__dirname);
+const framework = detect.detectFramework(deps);
 
-// 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;
-}
+// Map framework to base config
+// Note: Astro config only lints .astro files, so we combine it with TypeScript config
+// to also lint .ts files in Astro projects
+const baseConfigs = {
+  next: configs.recommendedTypeScriptNext,
+  react: configs.recommendedTypeScriptReact,
+  astro: [...configs.recommendedTypeScript, ...configs.astro],
+  typescript: configs.recommendedTypeScript,
+  javascript: configs.recommended,
+};
 
-// Start with ignores + safeword config
-const configs = [
-  { ignores },
-  ...baseConfig,
+export default [
+  { ignores: detect.getIgnores(deps) },
+  ...baseConfigs[framework],
+  ...(detect.hasVitest(deps) ? configs.vitest : []),
+  ...(detect.hasPlaywright(deps) ? configs.playwright : []),
+  ...(detect.hasTailwind(deps) ? configs.tailwind : []),
+  ...(detect.hasTanstackQuery(deps) ? configs.tanstackQuery : []),
+  eslintConfigPrettier,
 ];
-
-// Add test configs if testing frameworks detected
-if (deps["vitest"]) {
-  configs.push(...safeword.configs.vitest);
-}
-if (deps["playwright"] || deps["@playwright/test"]) {
-  configs.push(...safeword.configs.playwright);
+`;
 }
+function getFormatterAgnosticEslintConfig() {
+  return `import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import safeword from "eslint-plugin-safeword";
 
-// eslint-config-prettier must be last to disable conflicting rules
-configs.push(eslintConfigPrettier);
+const { detect, configs } = safeword;
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const deps = detect.collectAllDeps(__dirname);
+const framework = detect.detectFramework(deps);
 
-export default configs;
+// Map framework to base config
+// Note: Astro config only lints .astro files, so we combine it with TypeScript config
+// to also lint .ts files in Astro projects
+const baseConfigs = {
+  next: configs.recommendedTypeScriptNext,
+  react: configs.recommendedTypeScriptReact,
+  astro: [...configs.recommendedTypeScript, ...configs.astro],
+  typescript: configs.recommendedTypeScript,
+  javascript: configs.recommended,
+};
+
+export default [
+  { ignores: detect.getIgnores(deps) },
+  ...baseConfigs[framework],
+  ...(detect.hasVitest(deps) ? configs.vitest : []),
+  ...(detect.hasPlaywright(deps) ? configs.playwright : []),
+  ...(detect.hasTailwind(deps) ? configs.tailwind : []),
+  ...(detect.hasTanstackQuery(deps) ? configs.tanstackQuery : []),
+];
 `;
 }
 var CURSOR_HOOKS = {
@@ -645,7 +635,7 @@ Read it BEFORE working on any task in this project.
 
 // src/utils/hooks.ts
 function isHookEntry(h) {
-  return typeof h === "object" && h !== void 0 && "hooks" in h && Array.isArray(h.hooks);
+  return typeof h === "object" && h !== null && "hooks" in h && Array.isArray(h.hooks);
 }
 function isSafewordHook(h) {
   if (!isHookEntry(h)) return false;
@@ -822,6 +812,7 @@ var SAFEWORD_SCHEMA = {
       template: "skills/safeword-writing-plans/SKILL.md"
     },
     ".claude/commands/architecture.md": { template: "commands/architecture.md" },
+    ".claude/commands/audit.md": { template: "commands/audit.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" },
@@ -845,8 +836,9 @@ var SAFEWORD_SCHEMA = {
     ".cursor/rules/safeword-writing-plans.mdc": {
       template: "cursor/rules/safeword-writing-plans.mdc"
     },
-    // Cursor commands (4 files - same as Claude)
+    // Cursor commands (5 files - same as Claude)
     ".cursor/commands/architecture.md": { template: "commands/architecture.md" },
+    ".cursor/commands/audit.md": { template: "commands/audit.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" },
@@ -857,7 +849,7 @@ var SAFEWORD_SCHEMA = {
   // Files created if missing, updated only if content matches current template
   managedFiles: {
     "eslint.config.mjs": {
-      generator: () => getEslintConfig()
+      generator: (ctx) => getEslintConfig(ctx.projectType.existingFormatter)
     },
     // Minimal tsconfig for ESLint type-checked linting (only if missing)
     "tsconfig.json": {
@@ -883,6 +875,17 @@ var SAFEWORD_SCHEMA = {
           2
         );
       }
+    },
+    // Knip config for dead code detection (used by /audit)
+    "knip.json": {
+      generator: () => JSON.stringify(
+        {
+          ignore: [".safeword/**"],
+          ignoreDependencies: ["eslint-plugin-safeword"]
+        },
+        void 0,
+        2
+      )
     }
   },
   // JSON files where we merge specific keys
@@ -890,15 +893,23 @@ var SAFEWORD_SCHEMA = {
     "package.json": {
       keys: ["scripts.lint", "scripts.format", "scripts.format:check", "scripts.knip"],
       conditionalKeys: {
+        existingLinter: ["scripts.lint:eslint"],
+        // Projects with existing linter get separate ESLint script
         publishableLibrary: ["scripts.publint"],
         shell: ["scripts.lint:sh"]
       },
       merge: (existing, ctx) => {
         const scripts = { ...existing.scripts };
         const result = { ...existing };
-        if (!scripts.lint) scripts.lint = "eslint .";
-        if (!scripts.format) scripts.format = "prettier --write .";
-        if (!scripts["format:check"]) scripts["format:check"] = "prettier --check .";
+        if (ctx.projectType.existingLinter) {
+          if (!scripts["lint:eslint"]) scripts["lint:eslint"] = "eslint .";
+        } else {
+          if (!scripts.lint) scripts.lint = "eslint .";
+        }
+        if (!ctx.projectType.existingFormatter) {
+          if (!scripts.format) scripts.format = "prettier --write .";
+          if (!scripts["format:check"]) scripts["format:check"] = "prettier --check .";
+        }
         if (!scripts.knip) scripts.knip = "knip";
         if (ctx.projectType.publishableLibrary && !scripts.publint) {
           scripts.publint = "publint";
@@ -912,6 +923,7 @@ var SAFEWORD_SCHEMA = {
       unmerge: (existing) => {
         const result = { ...existing };
         const scripts = { ...existing.scripts };
+        delete scripts["lint:eslint"];
         delete scripts["lint:sh"];
         delete scripts["format:check"];
         delete scripts.knip;
@@ -1087,48 +1099,62 @@ var SAFEWORD_SCHEMA = {
   // NPM packages to install
   packages: {
     base: [
-      // Core tools
+      // Core tools (always needed)
       "eslint",
-      "prettier",
       // Safeword plugin (bundles eslint-config-prettier + all ESLint plugins)
       "eslint-plugin-safeword",
-      // Non-ESLint tools
+      // Architecture and dead code tools (used by /audit)
+      "dependency-cruiser",
       "knip"
     ],
     conditional: {
-      // Prettier plugins
+      // Prettier (only for projects without existing formatter)
+      standard: ["prettier"],
+      // "standard" = !existingFormatter
+      // Prettier plugins (only for projects without existing formatter that need them)
       astro: ["prettier-plugin-astro"],
       tailwind: ["prettier-plugin-tailwindcss"],
+      shell: ["prettier-plugin-sh"],
       // Non-ESLint tools
       publishableLibrary: ["publint"],
-      shell: ["shellcheck", "prettier-plugin-sh"]
+      shellcheck: ["shellcheck"]
+      // Renamed from shell to avoid conflict with prettier-plugin-sh
     }
   }
 };
 
 // src/utils/git.ts
-import nodePath3 from "path";
+import nodePath2 from "path";
 function isGitRepo(cwd) {
-  return exists(nodePath3.join(cwd, ".git"));
+  return exists(nodePath2.join(cwd, ".git"));
 }
 
 // src/utils/context.ts
-import nodePath5 from "path";
+import nodePath4 from "path";
 
 // src/utils/project-detector.ts
-import { readdirSync as readdirSync2 } from "fs";
-import nodePath4 from "path";
+import { readdirSync } from "fs";
+import nodePath3 from "path";
+import { detect } from "eslint-plugin-safeword";
+var {
+  TAILWIND_PACKAGES,
+  TANSTACK_QUERY_PACKAGES,
+  PLAYWRIGHT_PACKAGES,
+  FORMATTER_CONFIG_FILES,
+  hasExistingLinter,
+  hasExistingFormatter
+} = detect;
 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 });
+      const entries = readdirSync(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(nodePath4.join(dir, entry.name), depth + 1)) {
+        if (entry.isDirectory() && !excludeDirectories.has(entry.name) && scan(nodePath3.join(dir, entry.name), depth + 1)) {
           return true;
         }
       }
@@ -1142,16 +1168,20 @@ function detectProjectType(packageJson, cwd) {
   const deps = packageJson.dependencies || {};
   const developmentDeps = packageJson.devDependencies || {};
   const allDeps = { ...deps, ...developmentDeps };
+  const scripts = packageJson.scripts || {};
   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 hasVitest = "vitest" in developmentDeps;
   const hasPlaywright = "@playwright/test" in developmentDeps;
-  const hasTailwind = "tailwindcss" in allDeps;
+  const hasTailwind = TAILWIND_PACKAGES.some((pkg) => pkg in allDeps);
+  const hasTanstackQuery = TANSTACK_QUERY_PACKAGES.some((pkg) => pkg in allDeps);
   const hasEntryPoints = !!(packageJson.main || packageJson.module || packageJson.exports);
   const isPublishable = hasEntryPoints && packageJson.private !== true;
   const hasShell = cwd ? hasShellScripts(cwd) : false;
+  const hasLinter = hasExistingLinter(scripts);
+  const hasFormatter = cwd ? hasExistingFormatter(cwd, scripts) : "format" in scripts;
   return {
     typescript: hasTypescript,
     react: hasReact || hasNextJs,
@@ -1161,14 +1191,17 @@ function detectProjectType(packageJson, cwd) {
     vitest: hasVitest,
     playwright: hasPlaywright,
     tailwind: hasTailwind,
+    tanstackQuery: hasTanstackQuery,
     publishableLibrary: isPublishable,
-    shell: hasShell
+    shell: hasShell,
+    existingLinter: hasLinter,
+    existingFormatter: hasFormatter
   };
 }
 
 // src/utils/context.ts
 function createProjectContext(cwd) {
-  const packageJson = readJson(nodePath5.join(cwd, "package.json"));
+  const packageJson = readJson(nodePath4.join(cwd, "package.json"));
   return {
     cwd,
     projectType: detectProjectType(packageJson ?? {}, cwd),
@@ -1177,45 +1210,10 @@ function createProjectContext(cwd) {
   };
 }
 
-// src/utils/output.ts
-function info(message) {
-  console.log(message);
-}
-function success(message) {
-  console.log(`\u2713 ${message}`);
-}
-function warn(message) {
-  console.warn(`\u26A0 ${message}`);
-}
-function error(message) {
-  console.error(`\u2717 ${message}`);
-}
-function header(title) {
-  console.log(`
-${title}`);
-  console.log("\u2500".repeat(title.length));
-}
-function listItem(item, indent = 2) {
-  console.log(`${" ".repeat(indent)}\u2022 ${item}`);
-}
-function keyValue(key, value) {
-  console.log(`  ${key}: ${value}`);
-}
-
 export {
-  exists,
-  readFileSafe,
-  writeJson,
   reconcile,
   SAFEWORD_SCHEMA,
   isGitRepo,
-  createProjectContext,
-  info,
-  success,
-  warn,
-  error,
-  header,
-  listItem,
-  keyValue
+  createProjectContext
 };
-//# sourceMappingURL=chunk-H7PCVPAC.js.map
+//# sourceMappingURL=chunk-ZE6QJHZD.js.map