safeword 0.8.9 → 0.8.10

package/dist/{chunk-CLSGXTOL.js → chunk-POPS3ZRQ.js}

@@ -88,10 +88,428 @@ function writeJson(path, data) {
 `);
 }
 
+// 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 `/* eslint-disable import-x/no-unresolved, no-undef -- dynamic imports for optional framework plugins */
-import { readFileSync } from "fs";
+  return `import { readFileSync } from "fs";
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
 import safeword from "eslint-plugin-safeword";
@@ -102,27 +520,10 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(join(__dirname, "package.json"), "utf8"));
 const deps = { ...pkg.dependencies, ...pkg.devDependencies };
 
-// Helper for dynamic imports with actionable error messages
-async function tryImport(pkgName, frameworkName) {
-  try {
-    return await import(pkgName);
-  } catch (err) {
-    if (err.code === "ERR_MODULE_NOT_FOUND") {
-      console.error(\`\\n\u2717 Missing ESLint plugin for \${frameworkName}\\n\`);
-      console.error(\`Your package.json has \${frameworkName} but the ESLint plugin is not installed.\`);
-      console.error(\`Run: npm install -D \${pkgName}\\n\`);
-      console.error(\`Or run: npx safeword sync\\n\`);
-    }
-    throw err;
-  }
-}
-
 // Build dynamic ignores based on detected frameworks
 const ignores = ["**/node_modules/", "**/dist/", "**/build/", "**/coverage/"];
 if (deps["next"]) ignores.push(".next/");
 if (deps["astro"]) ignores.push(".astro/");
-if (deps["vue"] || deps["nuxt"]) ignores.push(".nuxt/");
-if (deps["svelte"] || deps["@sveltejs/kit"]) ignores.push(".svelte-kit/");
 
 // Select appropriate safeword config based on detected framework
 // Order matters: most specific first
@@ -153,22 +554,6 @@ if (deps["playwright"] || deps["@playwright/test"]) {
   configs.push(...safeword.configs.playwright);
 }
 
-// Frameworks NOT in eslint-plugin-safeword (dynamic imports)
-if (deps["vue"] || deps["nuxt"]) {
-  const vue = await tryImport("eslint-plugin-vue", "Vue");
-  configs.push(...vue.default.configs["flat/recommended"]);
-}
-
-if (deps["svelte"] || deps["@sveltejs/kit"]) {
-  const svelte = await tryImport("eslint-plugin-svelte", "Svelte");
-  configs.push(...svelte.default.configs.recommended);
-}
-
-if (deps["electron"]) {
-  const electron = await tryImport("@electron-toolkit/eslint-config", "Electron");
-  configs.push(electron.default);
-}
-
 // eslint-config-prettier must be last to disable conflicting rules
 configs.push(eslintConfigPrettier);
 
@@ -268,7 +653,6 @@ 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) {
@@ -303,16 +687,6 @@ var MCP_SERVERS = {
 };
 
 // src/schema.ts
-function isEslintPackage(pkg) {
-  return pkg.startsWith("eslint") || pkg.startsWith("@eslint/") || pkg.startsWith("@microsoft/eslint") || pkg.startsWith("@next/eslint") || pkg.startsWith("@vitest/eslint") || pkg.startsWith("@electron-toolkit/eslint") || pkg === "typescript-eslint";
-}
-function getBaseEslintPackages() {
-  return SAFEWORD_SCHEMA.packages.base.filter((pkg) => isEslintPackage(pkg));
-}
-function getConditionalEslintPackages(key) {
-  const deps = SAFEWORD_SCHEMA.packages.conditional[key];
-  return deps ? deps.filter((pkg) => isEslintPackage(pkg)) : [];
-}
 var SAFEWORD_SCHEMA = {
   version: VERSION,
   // Directories fully owned by safeword (created on setup, deleted on reset)
@@ -713,18 +1087,13 @@ var SAFEWORD_SCHEMA = {
       // Core tools
       "eslint",
       "prettier",
-      "eslint-config-prettier",
-      // Safeword plugin (bundles all ESLint plugins)
+      // Safeword plugin (bundles eslint-config-prettier + all ESLint plugins)
       "eslint-plugin-safeword",
       // Non-ESLint tools
       "markdownlint-cli2",
       "knip"
     ],
     conditional: {
-      // Frameworks NOT in eslint-plugin-safeword
-      vue: ["eslint-plugin-vue"],
-      svelte: ["eslint-plugin-svelte", "prettier-plugin-svelte"],
-      electron: ["@electron-toolkit/eslint-config"],
       // Prettier plugins
       astro: ["prettier-plugin-astro"],
       tailwind: ["prettier-plugin-tailwindcss"],
@@ -735,9 +1104,18 @@ var SAFEWORD_SCHEMA = {
   }
 };
 
+// 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 nodePath2 from "path";
+import nodePath4 from "path";
 function hasShellScripts(cwd, maxDepth = 4) {
   const excludeDirectories = /* @__PURE__ */ new Set(["node_modules", ".git", ".safeword"]);
   function scan(dir, depth) {
@@ -748,7 +1126,7 @@ function hasShellScripts(cwd, maxDepth = 4) {
         if (entry.isFile() && entry.name.endsWith(".sh")) {
           return true;
         }
-        if (entry.isDirectory() && !excludeDirectories.has(entry.name) && scan(nodePath2.join(dir, entry.name), depth + 1)) {
+        if (entry.isDirectory() && !excludeDirectories.has(entry.name) && scan(nodePath4.join(dir, entry.name), depth + 1)) {
           return true;
         }
       }
@@ -766,11 +1144,6 @@ function detectProjectType(packageJson, cwd) {
   const hasReact = "react" in deps || "react" in developmentDeps;
   const hasNextJs = "next" in deps;
   const hasAstro = "astro" in deps || "astro" in developmentDeps;
-  const hasVue = "vue" in deps || "vue" in developmentDeps;
-  const hasNuxt = "nuxt" in deps;
-  const hasSvelte = "svelte" in deps || "svelte" in developmentDeps;
-  const hasSvelteKit = "@sveltejs/kit" in deps || "@sveltejs/kit" in developmentDeps;
-  const hasElectron = "electron" in deps || "electron" in developmentDeps;
   const hasVitest = "vitest" in developmentDeps;
   const hasPlaywright = "@playwright/test" in developmentDeps;
   const hasTailwind = "tailwindcss" in allDeps;
@@ -783,13 +1156,6 @@ function detectProjectType(packageJson, cwd) {
     // Next.js implies React
     nextjs: hasNextJs,
     astro: hasAstro,
-    vue: hasVue || hasNuxt,
-    // Nuxt implies Vue
-    nuxt: hasNuxt,
-    svelte: hasSvelte || hasSvelteKit,
-    // SvelteKit implies Svelte
-    sveltekit: hasSvelteKit,
-    electron: hasElectron,
     vitest: hasVitest,
     playwright: hasPlaywright,
     tailwind: hasTailwind,
@@ -798,21 +1164,56 @@ function detectProjectType(packageJson, cwd) {
   };
 }
 
+// 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 {
-  getTemplatesDirectory,
   exists,
-  ensureDirectory,
-  readFile,
   readFileSafe,
-  writeFile,
-  remove,
-  removeIfEmpty,
-  makeScriptsExecutable,
-  readJson,
   writeJson,
-  getBaseEslintPackages,
-  getConditionalEslintPackages,
+  reconcile,
   SAFEWORD_SCHEMA,
-  detectProjectType
+  isGitRepo,
+  createProjectContext,
+  info,
+  success,
+  warn,
+  error,
+  header,
+  listItem,
+  keyValue
 };
-//# sourceMappingURL=chunk-CLSGXTOL.js.map
+//# sourceMappingURL=chunk-POPS3ZRQ.js.map