safeword 0.6.8 → 0.7.0

package/dist/{chunk-ZS3Z3Q37.js → chunk-QPO3C3FP.js}

@@ -88,7 +88,31 @@ function writeJson(path, data) {
 }
 
 // src/utils/project-detector.ts
-function detectProjectType(packageJson) {
+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 };
@@ -106,6 +130,7 @@ function detectProjectType(packageJson) {
   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,
@@ -122,7 +147,8 @@ function detectProjectType(packageJson) {
     vitest: hasVitest,
     playwright: hasPlaywright,
     tailwind: hasTailwind,
-    publishableLibrary: isPublishable
+    publishableLibrary: isPublishable,
+    shell: hasShell
   };
 }
 
@@ -145,28 +171,38 @@ function getPrettierConfig(projectType) {
   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";
 }
-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"]
-};
+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;
+}
 
 // src/templates/config.ts
 function getEslintConfig(options) {
-  return `import { readFileSync } from "fs";
+  return `/* eslint-disable import-x/no-unresolved -- dynamic imports for optional framework plugins */
+import { readFileSync } from "fs";
 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 eslintConfigPrettier from "eslint-config-prettier";
 ${options.boundaries ? 'import boundariesConfig from "./.safeword/eslint-boundaries.config.mjs";' : ""}
 
@@ -175,7 +211,7 @@ 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/"];
+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/");
@@ -186,12 +222,36 @@ 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
+    },
+  },
 ];
 
 // TypeScript support (detected from package.json)
-if (deps["typescript"]) {
+if (deps["typescript"] || deps["typescript-eslint"]) {
   const tseslint = await import("typescript-eslint");
   configs.push(importX.flatConfigs.typescript);
   configs.push(...tseslint.default.configs.recommended);
@@ -275,6 +335,10 @@ configs.push(eslintConfigPrettier);
 export default defineConfig(configs);
 `;
 }
+var CURSOR_HOOKS = {
+  afterFileEdit: [{ command: "./.safeword/hooks/cursor/after-file-edit.sh" }],
+  stop: [{ command: "./.safeword/hooks/cursor/stop.sh" }]
+};
 var SETTINGS_HOOKS = {
   SessionStart: [
     {
@@ -344,59 +408,124 @@ var SETTINGS_HOOKS = {
 };
 
 // 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
+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: [],
-  // 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"]
+  app: ["features", "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);
+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 {
+      }
     }
-    if (exists(join2(projectDir, dir))) {
-      foundAtRoot.push(dir);
+  }
+  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}`
+        });
+      }
     }
   }
-  const inSrc = foundInSrc.length >= foundAtRoot.length;
-  const found = inSrc ? foundInSrc : foundAtRoot;
-  return { directories: found, inSrc };
+}
+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));
+    }
+  }
+  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(", ");
+}
+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)}] }`;
+}
+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 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 || "";
+  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)
  *
@@ -422,13 +551,13 @@ export default {
 ${elementsContent}
     ],
   },
-  rules: {
+  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
   },
@@ -455,9 +584,7 @@ function isHookEntry(h) {
 }
 function isSafewordHook(h) {
   if (!isHookEntry(h)) return false;
-  return h.hooks.some(
-    (cmd) => typeof cmd.command === "string" && cmd.command.includes(".safeword")
-  );
+  return h.hooks.some((cmd) => typeof cmd.command === "string" && cmd.command.includes(".safeword"));
 }
 function filterOutSafewordHooks(hooks) {
   return hooks.filter((h) => !isSafewordHook(h));
@@ -470,16 +597,21 @@ var SAFEWORD_SCHEMA = {
   ownedDirs: [
     ".safeword",
     ".safeword/hooks",
+    ".safeword/hooks/cursor",
     ".safeword/lib",
     ".safeword/guides",
     ".safeword/templates",
     ".safeword/prompts",
     ".safeword/planning",
-    ".safeword/planning/user-stories",
+    ".safeword/planning/specs",
     ".safeword/planning/test-definitions",
     ".safeword/planning/design",
     ".safeword/planning/issues",
-    ".husky"
+    ".safeword/scripts",
+    ".husky",
+    ".cursor",
+    ".cursor/rules",
+    ".cursor/commands"
   ],
   // Directories we add to but don't own (not deleted on reset)
   sharedDirs: [".claude", ".claude/skills", ".claude/commands"],
@@ -520,13 +652,16 @@ var SAFEWORD_SCHEMA = {
     ".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)
+    // Templates (6 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/task-spec-template.md": {
+      template: "doc-templates/task-spec-template.md"
+    },
     ".safeword/templates/test-definitions-feature.md": {
       template: "doc-templates/test-definitions-feature.md"
     },
@@ -537,15 +672,36 @@ var SAFEWORD_SCHEMA = {
     // 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)
+    // Scripts (3 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/lint-md.sh": { template: "scripts/lint-md.sh" },
+    // Claude skills and commands (6 files)
     ".claude/skills/safeword-quality-reviewer/SKILL.md": {
       template: "skills/safeword-quality-reviewer/SKILL.md"
     },
+    ".claude/skills/safeword-systematic-debugger/SKILL.md": {
+      template: "skills/safeword-systematic-debugger/SKILL.md"
+    },
+    ".claude/skills/safeword-tdd-enforcer/SKILL.md": {
+      template: "skills/safeword-tdd-enforcer/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 }
+    ".husky/pre-commit": { content: HUSKY_PRE_COMMIT_CONTENT },
+    // Cursor rules (1 file)
+    ".cursor/rules/safeword-core.mdc": { template: "cursor/rules/safeword-core.mdc" },
+    // Cursor commands (3 files - same as Claude)
+    ".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" }
   },
   // Files created if missing, updated only if content matches current template
   managedFiles: {
@@ -568,7 +724,8 @@ var SAFEWORD_SCHEMA = {
         "lint-staged"
       ],
       conditionalKeys: {
-        publishableLibrary: ["scripts.publint"]
+        publishableLibrary: ["scripts.publint"],
+        shell: ["scripts.lint:sh"]
       },
       merge: (existing, ctx) => {
         const scripts = existing.scripts ?? {};
@@ -582,16 +739,20 @@ var SAFEWORD_SCHEMA = {
         if (ctx.projectType.publishableLibrary && !scripts.publint) {
           scripts.publint = "publint";
         }
+        if (ctx.projectType.shell && !scripts["lint:sh"]) {
+          scripts["lint:sh"] = "shellcheck **/*.sh";
+        }
         result.scripts = scripts;
         if (!existing["lint-staged"]) {
-          result["lint-staged"] = LINT_STAGED_CONFIG;
+          result["lint-staged"] = getLintStagedConfig(ctx.projectType);
         }
         return result;
       },
       unmerge: (existing) => {
         const result = { ...existing };
-        const scripts = { ...existing.scripts ?? {} };
+        const scripts = { ...existing.scripts };
         delete scripts["lint:md"];
+        delete scripts["lint:sh"];
         delete scripts["format:check"];
         delete scripts.knip;
         delete scripts.prepare;
@@ -651,7 +812,34 @@ var SAFEWORD_SCHEMA = {
       },
       unmerge: (existing) => {
         const result = { ...existing };
-        const mcpServers = { ...existing.mcpServers ?? {} };
+        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;
+      }
+    },
+    ".cursor/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) {
@@ -661,6 +849,35 @@ var SAFEWORD_SCHEMA = {
         }
         return result;
       }
+    },
+    ".cursor/hooks.json": {
+      keys: ["version", "hooks.afterFileEdit", "hooks.stop"],
+      removeFileIfEmpty: true,
+      merge: (existing) => {
+        const hooks = existing.hooks ?? {};
+        return {
+          ...existing,
+          version: 1,
+          // Required by Cursor
+          hooks: {
+            ...hooks,
+            ...CURSOR_HOOKS
+          }
+        };
+      },
+      unmerge: (existing) => {
+        const result = { ...existing };
+        const hooks = { ...existing.hooks };
+        delete hooks.afterFileEdit;
+        delete hooks.stop;
+        if (Object.keys(hooks).length > 0) {
+          result.hooks = hooks;
+        } else {
+          delete result.hooks;
+          delete result.version;
+        }
+        return result;
+      }
     }
   },
   // Text files where we patch specific content
@@ -686,7 +903,9 @@ var SAFEWORD_SCHEMA = {
       "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",
@@ -706,7 +925,8 @@ var SAFEWORD_SCHEMA = {
       electron: ["@electron-toolkit/eslint-config"],
       vitest: ["@vitest/eslint-plugin"],
       tailwind: ["prettier-plugin-tailwindcss"],
-      publishableLibrary: ["publint"]
+      publishableLibrary: ["publint"],
+      shell: ["shellcheck", "prettier-plugin-sh"]
     }
   }
 };
@@ -726,4 +946,4 @@ export {
   detectProjectType,
   SAFEWORD_SCHEMA
 };
-//# sourceMappingURL=chunk-ZS3Z3Q37.js.map
+//# sourceMappingURL=chunk-QPO3C3FP.js.map