safeword 0.8.7 → 0.8.10

package/dist/chunk-POPS3ZRQ.js

@@ -0,0 +1,1219 @@
+import {
+  VERSION
+} from "./chunk-ORQHKDT2.js";
+
+// src/utils/fs.ts
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  rmdirSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+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;
+    }
+  }
+  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);
+    }
+  }
+}
+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;
+}
+function planMissingDirectories(directories, cwd, isGitRepo2) {
+  const actions = [];
+  const created = [];
+  for (const dir of directories) {
+    if (shouldSkipForNonGit(dir, isGitRepo2)) continue;
+    if (!exists(nodePath2.join(cwd, dir))) {
+      actions.push({ type: "mkdir", path: dir });
+      created.push(dir);
+    }
+  }
+  return { actions, created };
+}
+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)) ?? "";
+    if (!content.includes(definition.marker)) {
+      actions.push({ type: "text-patch", path: filePath, definition });
+    }
+  }
+  return actions;
+}
+function planOwnedFileWrites(files, ctx) {
+  const actions = [];
+  const created = [];
+  for (const [filePath, definition] of Object.entries(files)) {
+    if (shouldSkipForNonGit(filePath, ctx.isGitRepo)) continue;
+    const content = resolveFileContent(definition, ctx);
+    actions.push({ type: "write", path: filePath, content });
+    created.push(filePath);
+  }
+  return { actions, created };
+}
+function planManagedFileWrites(files, ctx) {
+  const actions = [];
+  const created = [];
+  for (const [filePath, definition] of Object.entries(files)) {
+    if (exists(nodePath2.join(ctx.cwd, filePath))) continue;
+    const content = resolveFileContent(definition, ctx);
+    actions.push({ type: "write", path: filePath, content });
+    created.push(filePath);
+  }
+  return { actions, created };
+}
+function planTextPatchesWithCreation(patches, ctx, wouldCreate) {
+  const actions = [];
+  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))) {
+      wouldCreate.push(filePath);
+    }
+  }
+  return actions;
+}
+function planExistingDirectoriesRemoval(directories, cwd) {
+  const actions = [];
+  const removed = [];
+  for (const dir of directories) {
+    if (exists(nodePath2.join(cwd, dir))) {
+      actions.push({ type: "rmdir", path: dir });
+      removed.push(dir);
+    }
+  }
+  return { actions, removed };
+}
+function planExistingFilesRemoval(files, cwd) {
+  const actions = [];
+  const removed = [];
+  for (const filePath of files) {
+    if (exists(nodePath2.join(cwd, filePath))) {
+      actions.push({ type: "rm", path: filePath });
+      removed.push(filePath);
+    }
+  }
+  return { actions, removed };
+}
+function getClaudeParentDirectoryForCleanup(filePath) {
+  if (!filePath.startsWith(".claude/")) return void 0;
+  const parentDirectory = filePath.slice(0, Math.max(0, filePath.lastIndexOf("/")));
+  if (!parentDirectory || parentDirectory === ".claude" || parentDirectory === ".claude/skills" || parentDirectory === ".claude/commands") {
+    return void 0;
+  }
+  return parentDirectory;
+}
+async function reconcile(schema, mode, ctx, options) {
+  const dryRun = options?.dryRun ?? false;
+  const plan = computePlan(schema, mode, ctx);
+  if (dryRun) {
+    return {
+      actions: plan.actions,
+      applied: false,
+      created: plan.wouldCreate,
+      updated: plan.wouldUpdate,
+      removed: plan.wouldRemove,
+      packagesToInstall: plan.packagesToInstall,
+      packagesToRemove: plan.packagesToRemove
+    };
+  }
+  const result = executePlan(plan, ctx);
+  return {
+    actions: plan.actions,
+    applied: true,
+    created: result.created,
+    updated: result.updated,
+    removed: result.removed,
+    packagesToInstall: plan.packagesToInstall,
+    packagesToRemove: plan.packagesToRemove
+  };
+}
+function planDeprecatedFilesRemoval(deprecatedFiles, cwd) {
+  const actions = [];
+  const removed = [];
+  for (const filePath of deprecatedFiles) {
+    if (exists(nodePath2.join(cwd, filePath))) {
+      actions.push({ type: "rm", path: filePath });
+      removed.push(filePath);
+    }
+  }
+  return { actions, removed };
+}
+function computePlan(schema, mode, ctx) {
+  switch (mode) {
+    case "install": {
+      return computeInstallPlan(schema, ctx);
+    }
+    case "upgrade": {
+      return computeUpgradePlan(schema, ctx);
+    }
+    case "uninstall": {
+      return computeUninstallPlan(schema, ctx, false);
+    }
+    case "uninstall-full": {
+      return computeUninstallPlan(schema, ctx, true);
+    }
+    default: {
+      const _exhaustiveCheck = mode;
+      return _exhaustiveCheck;
+    }
+  }
+}
+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 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"];
+  if (ctx.isGitRepo) chmodPaths.push(HUSKY_DIR);
+  actions.push({ type: "chmod", paths: chmodPaths });
+  for (const [filePath, definition] of Object.entries(schema.jsonMerges)) {
+    actions.push({ type: "json-merge", path: filePath, definition });
+  }
+  actions.push(...planTextPatchesWithCreation(schema.textPatches, ctx, wouldCreate));
+  const packagesToInstall = computePackagesToInstall(schema, ctx.projectType, ctx.developmentDeps, ctx.isGitRepo);
+  return { actions, wouldCreate, wouldUpdate: [], wouldRemove: [], packagesToInstall, packagesToRemove: [] };
+}
+function computeUpgradePlan(schema, ctx) {
+  const actions = [];
+  const wouldCreate = [];
+  const wouldUpdate = [];
+  const allDirectories = [...schema.ownedDirs, ...schema.sharedDirs, ...schema.preservedDirs];
+  const missingDirectories = planMissingDirectories(allDirectories, ctx.cwd, ctx.isGitRepo);
+  actions.push(...missingDirectories.actions);
+  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 newContent = resolveFileContent(definition, ctx);
+    if (!fileNeedsUpdate(fullPath, newContent)) continue;
+    actions.push({ type: "write", path: filePath, content: newContent });
+    if (exists(fullPath)) {
+      wouldUpdate.push(filePath);
+    } else {
+      wouldCreate.push(filePath);
+    }
+  }
+  for (const [filePath, definition] of Object.entries(schema.managedFiles)) {
+    const fullPath = nodePath2.join(ctx.cwd, filePath);
+    const newContent = resolveFileContent(definition, ctx);
+    if (!exists(fullPath)) {
+      actions.push({ type: "write", path: filePath, content: newContent });
+      wouldCreate.push(filePath);
+    }
+  }
+  const deprecatedFiles = planDeprecatedFilesRemoval(schema.deprecatedFiles, ctx.cwd);
+  actions.push(...deprecatedFiles.actions);
+  const wouldRemove = deprecatedFiles.removed;
+  const deprecatedDirectories = planExistingDirectoriesRemoval(schema.deprecatedDirs, ctx.cwd);
+  actions.push(...deprecatedDirectories.actions);
+  wouldRemove.push(...deprecatedDirectories.removed);
+  const chmodPathsUpgrade = [
+    ".safeword/hooks",
+    ".safeword/hooks/cursor",
+    ".safeword/lib",
+    ".safeword/scripts"
+  ];
+  actions.push({ type: "chmod", paths: chmodPathsUpgrade });
+  for (const [filePath, definition] of Object.entries(schema.jsonMerges)) {
+    actions.push({ type: "json-merge", path: filePath, definition });
+  }
+  actions.push(...planTextPatches(schema.textPatches, ctx.cwd, ctx.isGitRepo));
+  const packagesToInstall = computePackagesToInstall(
+    schema,
+    ctx.projectType,
+    ctx.developmentDeps,
+    ctx.isGitRepo
+  );
+  const packagesToRemove = schema.deprecatedPackages.filter((pkg) => pkg in ctx.developmentDeps);
+  return {
+    actions,
+    wouldCreate,
+    wouldUpdate,
+    wouldRemove,
+    packagesToInstall,
+    packagesToRemove
+  };
+}
+function computeUninstallPlan(schema, ctx, full) {
+  const actions = [];
+  const wouldRemove = [];
+  const ownedFiles = planExistingFilesRemoval(Object.keys(schema.ownedFiles), ctx.cwd);
+  actions.push(...ownedFiles.actions);
+  wouldRemove.push(...ownedFiles.removed);
+  const directoriesToCleanup = /* @__PURE__ */ new Set();
+  for (const filePath of ownedFiles.removed) {
+    const parentDirectory = getClaudeParentDirectoryForCleanup(filePath);
+    if (parentDirectory) directoriesToCleanup.add(parentDirectory);
+  }
+  const cleanupDirectories = planExistingDirectoriesRemoval([...directoriesToCleanup], ctx.cwd);
+  actions.push(...cleanupDirectories.actions);
+  wouldRemove.push(...cleanupDirectories.removed);
+  for (const [filePath, definition] of Object.entries(schema.jsonMerges)) {
+    actions.push({ type: "json-unmerge", path: filePath, definition });
+  }
+  for (const [filePath, definition] of Object.entries(schema.textPatches)) {
+    const fullPath = nodePath2.join(ctx.cwd, filePath);
+    if (exists(fullPath)) {
+      const content = readFileSafe(fullPath) ?? "";
+      if (content.includes(definition.marker)) {
+        actions.push({ type: "text-unpatch", path: filePath, definition });
+      }
+    }
+  }
+  const preserved = planExistingDirectoriesRemoval(schema.preservedDirs.toReversed(), ctx.cwd);
+  actions.push(...preserved.actions);
+  wouldRemove.push(...preserved.removed);
+  const owned = planExistingDirectoriesRemoval(schema.ownedDirs.toReversed(), ctx.cwd);
+  actions.push(...owned.actions);
+  wouldRemove.push(...owned.removed);
+  if (full) {
+    const managed = planExistingFilesRemoval(Object.keys(schema.managedFiles), ctx.cwd);
+    actions.push(...managed.actions);
+    wouldRemove.push(...managed.removed);
+  }
+  const packagesToRemove = full ? computePackagesToRemove(schema, ctx.projectType, ctx.developmentDeps) : [];
+  return {
+    actions,
+    wouldCreate: [],
+    wouldUpdate: [],
+    wouldRemove,
+    packagesToInstall: [],
+    packagesToRemove
+  };
+}
+function executePlan(plan, ctx) {
+  const created = [];
+  const updated = [];
+  const removed = [];
+  const result = { created, updated, removed };
+  for (const action of plan.actions) {
+    executeAction(action, ctx, result);
+  }
+  return result;
+}
+function executeChmod(cwd, paths) {
+  for (const path of paths) {
+    const fullPath = nodePath2.join(cwd, path);
+    if (exists(fullPath)) makeScriptsExecutable(fullPath);
+  }
+}
+function executeRmdir(cwd, path, result) {
+  if (removeIfEmpty(nodePath2.join(cwd, path))) result.removed.push(path);
+}
+function executeAction(action, ctx, result) {
+  switch (action.type) {
+    case "mkdir":
+      ensureDirectory(nodePath2.join(ctx.cwd, action.path));
+      result.created.push(action.path);
+      break;
+    case "rmdir":
+      executeRmdir(ctx.cwd, action.path, result);
+      break;
+    case "write":
+      executeWrite(ctx.cwd, action.path, action.content, result);
+      break;
+    case "rm":
+      remove(nodePath2.join(ctx.cwd, action.path));
+      result.removed.push(action.path);
+      break;
+    case "chmod":
+      executeChmod(ctx.cwd, action.paths);
+      break;
+    case "json-merge":
+      executeJsonMerge(ctx.cwd, action.path, action.definition, ctx);
+      break;
+    case "json-unmerge":
+      executeJsonUnmerge(ctx.cwd, action.path, action.definition);
+      break;
+    case "text-patch":
+      executeTextPatch(ctx.cwd, action.path, action.definition);
+      break;
+    case "text-unpatch":
+      executeTextUnpatch(ctx.cwd, action.path, action.definition);
+      break;
+  }
+}
+function executeWrite(cwd, path, content, result) {
+  const fullPath = nodePath2.join(cwd, path);
+  const existed = exists(fullPath);
+  writeFile(fullPath, content);
+  (existed ? result.updated : result.created).push(path);
+}
+function resolveFileContent(definition, ctx) {
+  if (definition.template) {
+    const templatesDirectory = getTemplatesDirectory();
+    return readFile(nodePath2.join(templatesDirectory, definition.template));
+  }
+  if (definition.content) {
+    return typeof definition.content === "function" ? definition.content() : definition.content;
+  }
+  if (definition.generator) {
+    return definition.generator(ctx);
+  }
+  throw new Error("FileDefinition must have template, content, or generator");
+}
+function fileNeedsUpdate(installedPath, newContent) {
+  if (!exists(installedPath)) return true;
+  const currentContent = readFileSafe(installedPath);
+  return currentContent?.trim() !== newContent.trim();
+}
+var GIT_ONLY_PACKAGES = /* @__PURE__ */ new Set(["husky", "lint-staged"]);
+function computePackagesToInstall(schema, projectType, installedDevelopmentDeps, isGitRepo2 = true) {
+  let needed = [...schema.packages.base];
+  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);
+    }
+  }
+  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);
+    }
+  }
+  return safewordPackages.filter((pkg) => pkg in installedDevelopmentDeps);
+}
+function executeJsonMerge(cwd, path, definition, ctx) {
+  const fullPath = nodePath2.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);
+  if (!exists(fullPath)) return;
+  const existing = readJson(fullPath);
+  if (!existing) return;
+  const unmerged = definition.unmerge(existing);
+  if (definition.removeFileIfEmpty) {
+    const remainingKeys = Object.keys(unmerged).filter((k) => unmerged[k] !== void 0);
+    if (remainingKeys.length === 0) {
+      remove(fullPath);
+      return;
+    }
+  }
+  writeJson(fullPath, unmerged);
+}
+function executeTextPatch(cwd, path, definition) {
+  const fullPath = nodePath2.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 content = readFileSafe(fullPath);
+  if (!content) return;
+  let unpatched = content.replace(definition.content, "");
+  if (unpatched === content && content.includes(definition.marker)) {
+    const lines = content.split("\n");
+    const filtered = lines.filter((line) => !line.includes(definition.marker));
+    unpatched = filtered.join("\n").replace(/^\n+/, "");
+  }
+  writeFile(fullPath, unpatched);
+}
+
+// src/templates/config.ts
+function getEslintConfig() {
+  return `import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import safeword from "eslint-plugin-safeword";
+import eslintConfigPrettier from "eslint-config-prettier";
+
+// Read package.json relative to this config file (not CWD)
+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/");
+
+// 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 },
+  ...baseConfig,
+];
+
+// 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);
+}
+
+// eslint-config-prettier must be last to disable conflicting rules
+configs.push(eslintConfigPrettier);
+
+export default configs;
+`;
+}
+var CURSOR_HOOKS = {
+  afterFileEdit: [{ command: "./.safeword/hooks/cursor/after-file-edit.sh" }],
+  stop: [{ command: "./.safeword/hooks/cursor/stop.sh" }]
+};
+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/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.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, void 0, 2)}
+`;
+}
+
+// src/utils/hooks.ts
+function isHookEntry(h) {
+  return typeof h === "object" && h !== void 0 && "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/utils/install.ts
+var MCP_SERVERS = {
+  context7: {
+    command: "npx",
+    args: ["-y", "@upstash/context7-mcp@latest"]
+  },
+  playwright: {
+    command: "npx",
+    args: ["@playwright/mcp@latest"]
+  }
+};
+
+// src/schema.ts
+var SAFEWORD_SCHEMA = {
+  version: VERSION,
+  // Directories fully owned by safeword (created on setup, deleted on reset)
+  ownedDirs: [
+    ".safeword",
+    ".safeword/hooks",
+    ".safeword/hooks/cursor",
+    ".safeword/lib",
+    ".safeword/guides",
+    ".safeword/templates",
+    ".safeword/prompts",
+    ".safeword/planning",
+    ".safeword/planning/specs",
+    ".safeword/planning/test-definitions",
+    ".safeword/planning/design",
+    ".safeword/planning/issues",
+    ".safeword/planning/plans",
+    ".safeword/scripts",
+    ".cursor",
+    ".cursor/rules",
+    ".cursor/commands"
+  ],
+  // 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",
+    ".safeword/logs"
+  ],
+  // Files to delete on upgrade (renamed or removed in newer versions)
+  deprecatedFiles: [
+    ".safeword/templates/user-stories-template.md",
+    // Consolidated into planning-guide.md and testing-guide.md (v0.8.0)
+    ".safeword/guides/development-workflow.md",
+    ".safeword/guides/tdd-best-practices.md",
+    ".safeword/guides/user-story-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 },
+    // 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 (11 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/learning-extraction.md": { template: "guides/learning-extraction.md" },
+    ".safeword/guides/llm-guide.md": { template: "guides/llm-guide.md" },
+    ".safeword/guides/planning-guide.md": { template: "guides/planning-guide.md" },
+    ".safeword/guides/testing-guide.md": { template: "guides/testing-guide.md" },
+    ".safeword/guides/zombie-process-cleanup.md": { template: "guides/zombie-process-cleanup.md" },
+    // Templates (7 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"
+    },
+    ".safeword/templates/ticket-template.md": { template: "doc-templates/ticket-template.md" },
+    ".safeword/templates/feature-spec-template.md": {
+      template: "doc-templates/feature-spec-template.md"
+    },
+    ".safeword/templates/work-log-template.md": { template: "doc-templates/work-log-template.md" },
+    // Prompts (2 files)
+    ".safeword/prompts/architecture.md": { template: "prompts/architecture.md" },
+    ".safeword/prompts/quality-review.md": { template: "prompts/quality-review.md" },
+    // 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": {
+      template: "skills/safeword-brainstorming/SKILL.md"
+    },
+    ".claude/skills/safeword-debugging/SKILL.md": {
+      template: "skills/safeword-debugging/SKILL.md"
+    },
+    ".claude/skills/safeword-enforcing-tdd/SKILL.md": {
+      template: "skills/safeword-enforcing-tdd/SKILL.md"
+    },
+    ".claude/skills/safeword-quality-reviewer/SKILL.md": {
+      template: "skills/safeword-quality-reviewer/SKILL.md"
+    },
+    ".claude/skills/safeword-refactoring/SKILL.md": {
+      template: "skills/safeword-refactoring/SKILL.md"
+    },
+    ".claude/skills/safeword-writing-plans/SKILL.md": {
+      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" },
+    // Cursor rules (7 files)
+    ".cursor/rules/safeword-core.mdc": { template: "cursor/rules/safeword-core.mdc" },
+    ".cursor/rules/safeword-brainstorming.mdc": {
+      template: "cursor/rules/safeword-brainstorming.mdc"
+    },
+    ".cursor/rules/safeword-debugging.mdc": {
+      template: "cursor/rules/safeword-debugging.mdc"
+    },
+    ".cursor/rules/safeword-enforcing-tdd.mdc": {
+      template: "cursor/rules/safeword-enforcing-tdd.mdc"
+    },
+    ".cursor/rules/safeword-quality-reviewer.mdc": {
+      template: "cursor/rules/safeword-quality-reviewer.mdc"
+    },
+    ".cursor/rules/safeword-refactoring.mdc": {
+      template: "cursor/rules/safeword-refactoring.mdc"
+    },
+    ".cursor/rules/safeword-writing-plans.mdc": {
+      template: "cursor/rules/safeword-writing-plans.mdc"
+    },
+    // 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 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: {
+    "eslint.config.mjs": {
+      generator: () => getEslintConfig()
+    },
+    ".prettierrc": { generator: (ctx) => getPrettierConfig(ctx.projectType) },
+    ".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: {
+    "package.json": {
+      keys: [
+        "scripts.lint",
+        "scripts.lint:md",
+        "scripts.format",
+        "scripts.format:check",
+        "scripts.knip"
+      ],
+      conditionalKeys: {
+        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["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 (ctx.projectType.publishableLibrary && !scripts.publint) {
+          scripts.publint = "publint";
+        }
+        if (ctx.projectType.shell && !scripts["lint:sh"]) {
+          scripts["lint:sh"] = "shellcheck **/*.sh";
+        }
+        result.scripts = scripts;
+        return result;
+      },
+      unmerge: (existing) => {
+        const result = { ...existing };
+        const scripts = { ...existing.scripts };
+        delete scripts["lint:md"];
+        delete scripts["lint:sh"];
+        delete scripts["format:check"];
+        delete scripts.knip;
+        delete scripts.publint;
+        if (Object.keys(scripts).length > 0) {
+          result.scripts = scripts;
+        } else {
+          delete result.scripts;
+        }
+        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;
+      }
+    },
+    ".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) {
+          result.mcpServers = mcpServers;
+        } else {
+          delete result.mcpServers;
+        }
+        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
+  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: [
+      // Core tools
+      "eslint",
+      "prettier",
+      // Safeword plugin (bundles eslint-config-prettier + all ESLint plugins)
+      "eslint-plugin-safeword",
+      // Non-ESLint tools
+      "markdownlint-cli2",
+      "knip"
+    ],
+    conditional: {
+      // Prettier plugins
+      astro: ["prettier-plugin-astro"],
+      tailwind: ["prettier-plugin-tailwindcss"],
+      // Non-ESLint tools
+      publishableLibrary: ["publint"],
+      shell: ["shellcheck", "prettier-plugin-sh"]
+    }
+  }
+};
+
+// src/utils/git.ts
+import nodePath3 from "path";
+function isGitRepo(cwd) {
+  return exists(nodePath3.join(cwd, ".git"));
+}
+
+// src/utils/context.ts
+import nodePath5 from "path";
+
+// src/utils/project-detector.ts
+import { readdirSync as readdirSync2 } from "fs";
+import nodePath4 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(nodePath4.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 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,
+    vitest: hasVitest,
+    playwright: hasPlaywright,
+    tailwind: hasTailwind,
+    publishableLibrary: isPublishable,
+    shell: hasShell
+  };
+}
+
+// src/utils/context.ts
+function createProjectContext(cwd) {
+  const packageJson = readJson(nodePath5.join(cwd, "package.json"));
+  return {
+    cwd,
+    projectType: detectProjectType(packageJson ?? {}, cwd),
+    developmentDeps: packageJson?.devDependencies ?? {},
+    isGitRepo: isGitRepo(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
+};
+//# sourceMappingURL=chunk-POPS3ZRQ.js.map