permachine 0.5.0 → 0.5.2

package/dist/cli.js

@@ -5934,6 +5934,10 @@ function matchFilters(filename, context) {
 function getBaseFilename(filename) {
   return parseFilters(filename).baseFilename;
 }
+function isBaseFile(filename) {
+  const basename = filename.includes("/") || filename.includes("\\") ? filename.split(/[/\\]/).pop() || filename : filename;
+  return basename.includes(".base.") || basename.endsWith(".base");
+}
 function isLegacyFilename(filename, machineName) {
   const middlePattern = new RegExp(`\\.${machineName}\\.`, "i");
   const endPattern = new RegExp(`\\.${machineName}$`, "i");
@@ -5943,6 +5947,8 @@ function isLegacyFilename(filename, machineName) {
 // src/core/file-scanner.ts
 async function scanForMergeOperations(machineName, cwd = process.cwd()) {
   const operations = [];
+  const processedOutputs = new Set;
+  const baseFilesWithMachineFiles = new Set;
   const patterns = [
     "**/*{*}*",
     `**/*.${machineName}.*`,
@@ -5965,25 +5971,93 @@ async function scanForMergeOperations(machineName, cwd = process.cwd()) {
   const context = createCustomContext({ machine: machineName });
   for (const file of uniqueFiles) {
     const basename = path2.basename(file);
-    if (basename.includes(".base.") || basename.includes(".base")) {
+    if (isBaseFile(basename)) {
       continue;
     }
     let shouldProcess = false;
     if (hasFilters(basename)) {
       const result = matchFilters(basename, context);
       shouldProcess = result.matches;
+      const operation = createMergeOperation(file, machineName, cwd);
+      if (operation && operation.basePath) {
+        baseFilesWithMachineFiles.add(operation.basePath);
+      }
     } else if (isLegacyFilename(basename, machineName)) {
       shouldProcess = true;
+      const operation = createMergeOperation(file, machineName, cwd);
+      if (operation && operation.basePath) {
+        baseFilesWithMachineFiles.add(operation.basePath);
+      }
     }
     if (shouldProcess) {
       const operation = createMergeOperation(file, machineName, cwd);
       if (operation) {
         operations.push(operation);
+        processedOutputs.add(operation.outputPath);
       }
     }
   }
+  const basePatterns = [
+    "**/*.base.json",
+    "**/.*.base",
+    "**/.*.base.*"
+  ];
+  for (const pattern of basePatterns) {
+    try {
+      const baseFiles = await glob(pattern, {
+        cwd,
+        ignore: ["node_modules/**", ".git/**", "dist/**"],
+        dot: true,
+        nodir: true
+      });
+      for (const baseFile of baseFiles) {
+        const fullPath = path2.join(cwd, baseFile);
+        if (baseFilesWithMachineFiles.has(fullPath)) {
+          continue;
+        }
+        const operation = createBaseOnlyMergeOperation(baseFile, cwd);
+        if (operation && !processedOutputs.has(operation.outputPath)) {
+          operations.push(operation);
+          processedOutputs.add(operation.outputPath);
+        }
+      }
+    } catch (error) {}
+  }
   return operations;
 }
+function createBaseOnlyMergeOperation(baseFile, cwd) {
+  const dir = path2.dirname(baseFile);
+  const fullBasename = path2.basename(baseFile);
+  let type;
+  let ext2;
+  if (fullBasename.endsWith(".json") || fullBasename.includes(".base.json") || fullBasename.includes(".{base}.json")) {
+    type = "json";
+    ext2 = ".json";
+  } else if (fullBasename.startsWith(".env")) {
+    type = "env";
+    ext2 = "";
+  } else {
+    type = "unknown";
+    ext2 = path2.extname(baseFile);
+  }
+  if (type === "unknown") {
+    return null;
+  }
+  let outputName;
+  if (type === "env") {
+    outputName = fullBasename.replace(".base", "").replace(".{base}", "");
+  } else {
+    outputName = fullBasename.replace(".base", "").replace(".{base}", "");
+  }
+  const basePath = path2.join(cwd, baseFile);
+  const outputPath = path2.join(cwd, dir, outputName);
+  return {
+    basePath,
+    machinePath: "",
+    outputPath,
+    type
+  };
+}
 function createMergeOperation(machineFile, machineName, cwd) {
   const dir = path2.dirname(machineFile);
   const fullBasename = path2.basename(machineFile);
@@ -6458,6 +6532,142 @@ async function isFileTrackedByGit(filePath, cwd) {
   }
 }
 
+// src/core/git-hooks.ts
+import fs3 from "node:fs/promises";
+import path6 from "node:path";
+import { exec as exec2 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+var execAsync2 = promisify2(exec2);
+var __filename2 = fileURLToPath3(import.meta.url);
+var __dirname2 = path6.dirname(__filename2);
+var HOOK_NAMES = ["post-checkout", "post-merge", "post-commit"];
+var HOOKS_DIR = ".permachine/hooks";
+async function installHooks(options = {}) {
+  const warnings = [];
+  if (!await isGitRepository()) {
+    throw new Error('Not a git repository. Run "git init" first.');
+  }
+  const cwd = process.cwd();
+  const existingHooksPath = await getGitConfig("core.hooksPath");
+  if (existingHooksPath && existingHooksPath !== HOOKS_DIR && !options.legacy) {
+    warnings.push(`Git core.hooksPath is already set to: ${existingHooksPath}`, "Use --legacy flag to install hooks in .git/hooks instead");
+  }
+  const useLegacy = options.legacy || existingHooksPath && existingHooksPath !== HOOKS_DIR;
+  if (useLegacy) {
+    return await installLegacyHooks(warnings);
+  } else {
+    return await installHooksPathMethod(warnings);
+  }
+}
+async function installHooksPathMethod(warnings) {
+  const cwd = process.cwd();
+  const hooksDir = path6.join(cwd, HOOKS_DIR);
+  await fs3.mkdir(hooksDir, { recursive: true });
+  let templatesDir = path6.join(__dirname2, "../../templates/hooks");
+  if (!await fileExists2(path6.join(templatesDir, "post-checkout"))) {
+    templatesDir = path6.join(__dirname2, "../templates/hooks");
+  }
+  const installedHooks = [];
+  for (const hookName of HOOK_NAMES) {
+    const templatePath = path6.join(templatesDir, hookName);
+    const hookPath = path6.join(hooksDir, hookName);
+    const content = await fs3.readFile(templatePath, "utf-8");
+    await fs3.writeFile(hookPath, content, { mode: 493 });
+    installedHooks.push(hookName);
+  }
+  await setGitConfig("core.hooksPath", HOOKS_DIR);
+  logger.success(`Installed git hooks via core.hooksPath`);
+  return {
+    method: "hooksPath",
+    hooksInstalled: installedHooks,
+    warnings
+  };
+}
+async function installLegacyHooks(warnings) {
+  const cwd = process.cwd();
+  const gitHooksDir = path6.join(cwd, ".git/hooks");
+  const installedHooks = [];
+  for (const hookName of HOOK_NAMES) {
+    const hookPath = path6.join(gitHooksDir, hookName);
+    const backupPath = path6.join(gitHooksDir, `${hookName}.pre-mcs`);
+    const hookExists = await fileExists2(hookPath);
+    if (hookExists) {
+      await fs3.rename(hookPath, backupPath);
+    }
+    const hookContent = `#!/bin/sh
+# Auto-generated by permachine (legacy mode)
+
+permachine merge --silent
+
+# Call original hook if it existed
+if [ -f "${backupPath}" ]; then
+  "${backupPath}" "$@"
+fi
+
+exit 0
+`;
+    await fs3.writeFile(hookPath, hookContent, { mode: 493 });
+    installedHooks.push(hookName);
+  }
+  logger.success("Installed git hooks via legacy .git/hooks wrapping");
+  return {
+    method: "legacy",
+    hooksInstalled: installedHooks,
+    warnings
+  };
+}
+async function uninstallHooks() {
+  const cwd = process.cwd();
+  const hooksPath = await getGitConfig("core.hooksPath");
+  if (hooksPath === HOOKS_DIR) {
+    await execAsync2("git config --unset core.hooksPath");
+    const hooksDir = path6.join(cwd, HOOKS_DIR);
+    await fs3.rm(hooksDir, { recursive: true, force: true });
+    logger.success("Uninstalled git hooks (removed core.hooksPath)");
+  } else {
+    const gitHooksDir = path6.join(cwd, ".git/hooks");
+    for (const hookName of HOOK_NAMES) {
+      const hookPath = path6.join(gitHooksDir, hookName);
+      const backupPath = path6.join(gitHooksDir, `${hookName}.pre-mcs`);
+      if (await fileExists2(hookPath)) {
+        await fs3.unlink(hookPath);
+      }
+      if (await fileExists2(backupPath)) {
+        await fs3.rename(backupPath, hookPath);
+      }
+    }
+    logger.success("Uninstalled git hooks (restored original hooks)");
+  }
+}
+async function isGitRepository() {
+  try {
+    await execAsync2("git rev-parse --git-dir");
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getGitConfig(key) {
+  try {
+    const { stdout } = await execAsync2(`git config --get ${key}`);
+    return stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+async function setGitConfig(key, value) {
+  await execAsync2(`git config ${key} "${value}"`);
+}
+async function fileExists2(filePath) {
+  try {
+    await fs3.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 // node_modules/chokidar/index.js
 import { EventEmitter as EventEmitter2 } from "node:events";
 import { stat as statcb, Stats } from "node:fs";
@@ -6549,7 +6759,7 @@ class ReaddirpStream extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat2 : stat;
     if (wantBigintFsStats) {
-      this._stat = (path6) => statMethod(path6, { bigint: true });
+      this._stat = (path7) => statMethod(path7, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -6574,8 +6784,8 @@ class ReaddirpStream extends Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path6, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path6));
+          const { path: path7, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path7));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -6615,20 +6825,20 @@ class ReaddirpStream extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path6, depth) {
+  async _exploreDir(path7, depth) {
     let files;
     try {
-      files = await readdir2(path6, this._rdOptions);
+      files = await readdir2(path7, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path6 };
+    return { files, depth, path: path7 };
   }
-  async _formatEntry(dirent, path6) {
+  async _formatEntry(dirent, path7) {
     let entry;
     const basename = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path6, basename));
+      const fullPath = presolve(pjoin(path7, basename));
       entry = { path: prelative(this._root, fullPath), fullPath, basename };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -7027,16 +7237,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = new Map;
-function createFsWatchInstance(path6, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path7, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path6);
-    emitRaw(rawEvent, evPath, { watchedPath: path6 });
-    if (evPath && path6 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path6, evPath), KEY_LISTENERS, sp.join(path6, evPath));
+    listener(path7);
+    emitRaw(rawEvent, evPath, { watchedPath: path7 });
+    if (evPath && path7 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path7, evPath), KEY_LISTENERS, sp.join(path7, evPath));
     }
   };
   try {
-    return fs_watch(path6, {
+    return fs_watch(path7, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -7052,12 +7262,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path6, fullPath, options, handlers) => {
+var setFsWatchListener = (path7, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path6, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path7, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -7067,7 +7277,7 @@ var setFsWatchListener = (path6, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_ERR, errHandler);
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
-    watcher = createFsWatchInstance(path6, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
+    watcher = createFsWatchInstance(path7, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
     if (!watcher)
       return;
     watcher.on(EV.ERROR, async (error) => {
@@ -7076,7 +7286,7 @@ var setFsWatchListener = (path6, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open(path6, "r");
+          const fd = await open(path7, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {}
@@ -7106,7 +7316,7 @@ var setFsWatchListener = (path6, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = new Map;
-var setFsWatchFileListener = (path6, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path7, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -7128,7 +7338,7 @@ var setFsWatchFileListener = (path6, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path6, curr));
+          foreach(cont.listeners, (listener2) => listener2(path7, curr));
         }
       })
     };
@@ -7153,13 +7363,13 @@ class NodeFsHandler {
     this.fsw = fsW;
     this._boundHandleError = (error) => fsW._handleError(error);
   }
-  _watchWithNodeFs(path6, listener) {
+  _watchWithNodeFs(path7, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path6);
-    const basename2 = sp.basename(path6);
+    const directory = sp.dirname(path7);
+    const basename2 = sp.basename(path7);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename2);
-    const absolutePath = sp.resolve(path6);
+    const absolutePath = sp.resolve(path7);
     const options = {
       persistent: opts.persistent
     };
@@ -7169,12 +7379,12 @@ class NodeFsHandler {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename2) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path6, absolutePath, options, {
+      closer = setFsWatchFileListener(path7, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path6, absolutePath, options, {
+      closer = setFsWatchListener(path7, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -7192,7 +7402,7 @@ class NodeFsHandler {
     let prevStats = stats;
     if (parent.has(basename2))
       return;
-    const listener = async (path6, newStats) => {
+    const listener = async (path7, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -7206,11 +7416,11 @@ class NodeFsHandler {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path6);
+            this.fsw._closeFile(path7);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path6, closer2);
+              this.fsw._addPathCloser(path7, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -7234,7 +7444,7 @@ class NodeFsHandler {
     }
     return closer;
   }
-  async _handleSymlink(entry, directory, path6, item) {
+  async _handleSymlink(entry, directory, path7, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -7244,7 +7454,7 @@ class NodeFsHandler {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path6);
+        linkPath = await fsrealpath(path7);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -7254,12 +7464,12 @@ class NodeFsHandler {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path6, entry.stats);
+          this.fsw._emit(EV.CHANGE, path7, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path6, entry.stats);
+        this.fsw._emit(EV.ADD, path7, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -7289,9 +7499,9 @@ class NodeFsHandler {
         return;
       }
       const item = entry.path;
-      let path6 = sp.join(directory, item);
+      let path7 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path6, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path7, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -7300,8 +7510,8 @@ class NodeFsHandler {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path6 = sp.join(dir, sp.relative(dir, path6));
-        this._addToNodeFs(path6, initialAdd, wh, depth + 1);
+        path7 = sp.join(dir, sp.relative(dir, path7));
+        this._addToNodeFs(path7, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve2, reject) => {
@@ -7350,13 +7560,13 @@ class NodeFsHandler {
     }
     return closer;
   }
-  async _addToNodeFs(path6, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path7, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path6) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path7) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path6);
+    const wh = this.fsw._getWatchHelpers(path7);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -7372,8 +7582,8 @@ class NodeFsHandler {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path6);
-        const targetPath = follow ? await fsrealpath(path6) : path6;
+        const absPath = sp.resolve(path7);
+        const targetPath = follow ? await fsrealpath(path7) : path7;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -7383,29 +7593,29 @@ class NodeFsHandler {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path6) : path6;
+        const targetPath = follow ? await fsrealpath(path7) : path7;
         if (this.fsw.closed)
           return;
         const parent = sp.dirname(wh.watchPath);
         this.fsw._getWatchedDir(parent).add(wh.watchPath);
         this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path6, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path7, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== undefined) {
-          this.fsw._symlinkPaths.set(sp.resolve(path6), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path7), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path6, closer);
+        this.fsw._addPathCloser(path7, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path6;
+        return path7;
       }
     }
   }
@@ -7449,24 +7659,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path6) {
-  if (typeof path6 !== "string")
+function normalizePath(path7) {
+  if (typeof path7 !== "string")
     throw new Error("string expected");
-  path6 = sp2.normalize(path6);
-  path6 = path6.replace(/\\/g, "/");
+  path7 = sp2.normalize(path7);
+  path7 = path7.replace(/\\/g, "/");
   let prepend = false;
-  if (path6.startsWith("//"))
+  if (path7.startsWith("//"))
     prepend = true;
-  path6 = path6.replace(DOUBLE_SLASH_RE, "/");
+  path7 = path7.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path6 = "/" + path6;
-  return path6;
+    path7 = "/" + path7;
+  return path7;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path6 = normalizePath(testString);
+  const path7 = normalizePath(testString);
   for (let index = 0;index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path6, stats)) {
+    if (pattern(path7, stats)) {
       return true;
     }
   }
@@ -7504,19 +7714,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path6) => toUnix(sp2.normalize(toUnix(path6)));
-var normalizeIgnored = (cwd = "") => (path6) => {
-  if (typeof path6 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path6) ? path6 : sp2.join(cwd, path6));
+var normalizePathToUnix = (path7) => toUnix(sp2.normalize(toUnix(path7)));
+var normalizeIgnored = (cwd = "") => (path7) => {
+  if (typeof path7 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path7) ? path7 : sp2.join(cwd, path7));
   } else {
-    return path6;
+    return path7;
   }
 };
-var getAbsolutePath = (path6, cwd) => {
-  if (sp2.isAbsolute(path6)) {
-    return path6;
+var getAbsolutePath = (path7, cwd) => {
+  if (sp2.isAbsolute(path7)) {
+    return path7;
   }
-  return sp2.join(cwd, path6);
+  return sp2.join(cwd, path7);
 };
 var EMPTY_SET = Object.freeze(new Set);
 
@@ -7583,10 +7793,10 @@ class WatchHelper {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path6, follow, fsw) {
+  constructor(path7, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path6;
-    this.path = path6 = path6.replace(REPLACER_RE, "");
+    const watchPath = path7;
+    this.path = path7 = path7.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -7717,20 +7927,20 @@ class FSWatcher extends EventEmitter2 {
     this._closePromise = undefined;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path6) => {
-        const absPath = getAbsolutePath(path6, cwd);
+      paths = paths.map((path7) => {
+        const absPath = getAbsolutePath(path7, cwd);
         return absPath;
       });
     }
-    paths.forEach((path6) => {
-      this._removeIgnoredPath(path6);
+    paths.forEach((path7) => {
+      this._removeIgnoredPath(path7);
     });
     this._userIgnored = undefined;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path6) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path6, !_internal, undefined, 0, _origAdd);
+    Promise.all(paths.map(async (path7) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path7, !_internal, undefined, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -7749,17 +7959,17 @@ class FSWatcher extends EventEmitter2 {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path6) => {
-      if (!sp2.isAbsolute(path6) && !this._closers.has(path6)) {
+    paths.forEach((path7) => {
+      if (!sp2.isAbsolute(path7) && !this._closers.has(path7)) {
         if (cwd)
-          path6 = sp2.join(cwd, path6);
-        path6 = sp2.resolve(path6);
+          path7 = sp2.join(cwd, path7);
+        path7 = sp2.resolve(path7);
       }
-      this._closePath(path6);
-      this._addIgnoredPath(path6);
-      if (this._watched.has(path6)) {
+      this._closePath(path7);
+      this._addIgnoredPath(path7);
+      if (this._watched.has(path7)) {
         this._addIgnoredPath({
-          path: path6,
+          path: path7,
           recursive: true
         });
       }
@@ -7808,38 +8018,38 @@ class FSWatcher extends EventEmitter2 {
     if (event !== EVENTS.ERROR)
       this.emit(EVENTS.ALL, event, ...args);
   }
-  async _emit(event, path6, stats) {
+  async _emit(event, path7, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path6 = sp2.normalize(path6);
+      path7 = sp2.normalize(path7);
     if (opts.cwd)
-      path6 = sp2.relative(opts.cwd, path6);
-    const args = [path6];
+      path7 = sp2.relative(opts.cwd, path7);
+    const args = [path7];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path6))) {
+    if (awf && (pw = this._pendingWrites.get(path7))) {
       pw.lastChange = new Date;
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path6, [event, ...args]);
+        this._pendingUnlinks.set(path7, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path7) => {
+          this._pendingUnlinks.forEach((entry, path8) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path7);
+            this._pendingUnlinks.delete(path8);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path6)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path7)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path6);
+        this._pendingUnlinks.delete(path7);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -7857,16 +8067,16 @@ class FSWatcher extends EventEmitter2 {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path6, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path7, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path6, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path7, 50);
       if (isThrottled)
         return this;
     }
     if (opts.alwaysStat && stats === undefined && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-      const fullPath = opts.cwd ? sp2.join(opts.cwd, path6) : path6;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path7) : path7;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -7885,23 +8095,23 @@ class FSWatcher extends EventEmitter2 {
     }
     return error || this.closed;
   }
-  _throttle(actionType, path6, timeout) {
+  _throttle(actionType, path7, timeout) {
     if (!this._throttled.has(actionType)) {
       this._throttled.set(actionType, new Map);
     }
     const action = this._throttled.get(actionType);
     if (!action)
       throw new Error("invalid throttle");
-    const actionPath = action.get(path6);
+    const actionPath = action.get(path7);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path6);
+      const item = action.get(path7);
       const count = item ? item.count : 0;
-      action.delete(path6);
+      action.delete(path7);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -7909,50 +8119,50 @@ class FSWatcher extends EventEmitter2 {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path6, thr);
+    action.set(path7, thr);
     return thr;
   }
   _incrReadyCount() {
     return this._readyCount++;
   }
-  _awaitWriteFinish(path6, threshold, event, awfEmit) {
+  _awaitWriteFinish(path7, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path6;
-    if (this.options.cwd && !sp2.isAbsolute(path6)) {
-      fullPath = sp2.join(this.options.cwd, path6);
+    let fullPath = path7;
+    if (this.options.cwd && !sp2.isAbsolute(path7)) {
+      fullPath = sp2.join(this.options.cwd, path7);
     }
     const now = new Date;
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path6)) {
+        if (err || !writes.has(path7)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(new Date);
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path6).lastChange = now2;
+          writes.get(path7).lastChange = now2;
         }
-        const pw = writes.get(path6);
+        const pw = writes.get(path7);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path6);
+          writes.delete(path7);
           awfEmit(undefined, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path6)) {
-      writes.set(path6, {
+    if (!writes.has(path7)) {
+      writes.set(path7, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path6);
+          writes.delete(path7);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -7960,8 +8170,8 @@ class FSWatcher extends EventEmitter2 {
       timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
     }
   }
-  _isIgnored(path6, stats) {
-    if (this.options.atomic && DOT_RE.test(path6))
+  _isIgnored(path7, stats) {
+    if (this.options.atomic && DOT_RE.test(path7))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -7971,13 +8181,13 @@ class FSWatcher extends EventEmitter2 {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, undefined);
     }
-    return this._userIgnored(path6, stats);
+    return this._userIgnored(path7, stats);
   }
-  _isntIgnored(path6, stat4) {
-    return !this._isIgnored(path6, stat4);
+  _isntIgnored(path7, stat4) {
+    return !this._isIgnored(path7, stat4);
   }
-  _getWatchHelpers(path6) {
-    return new WatchHelper(path6, this.options.followSymlinks, this);
+  _getWatchHelpers(path7) {
+    return new WatchHelper(path7, this.options.followSymlinks, this);
   }
   _getWatchedDir(directory) {
     const dir = sp2.resolve(directory);
@@ -7991,57 +8201,57 @@ class FSWatcher extends EventEmitter2 {
     return Boolean(Number(stats.mode) & 256);
   }
   _remove(directory, item, isDirectory) {
-    const path6 = sp2.join(directory, item);
-    const fullPath = sp2.resolve(path6);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path6) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path6, 100))
+    const path7 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path7);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path7) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path7, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path6);
+    const wp = this._getWatchedDir(path7);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path6, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path7, nested));
     const parent = this._getWatchedDir(directory);
     const wasTracked = parent.has(item);
     parent.remove(item);
     if (this._symlinkPaths.has(fullPath)) {
       this._symlinkPaths.delete(fullPath);
     }
-    let relPath = path6;
+    let relPath = path7;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path6);
+      relPath = sp2.relative(this.options.cwd, path7);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path6);
+    this._watched.delete(path7);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path6))
-      this._emit(eventName, path6);
-    this._closePath(path6);
+    if (wasTracked && !this._isIgnored(path7))
+      this._emit(eventName, path7);
+    this._closePath(path7);
   }
-  _closePath(path6) {
-    this._closeFile(path6);
-    const dir = sp2.dirname(path6);
-    this._getWatchedDir(dir).remove(sp2.basename(path6));
+  _closePath(path7) {
+    this._closeFile(path7);
+    const dir = sp2.dirname(path7);
+    this._getWatchedDir(dir).remove(sp2.basename(path7));
   }
-  _closeFile(path6) {
-    const closers = this._closers.get(path6);
+  _closeFile(path7) {
+    const closers = this._closers.get(path7);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path6);
+    this._closers.delete(path7);
   }
-  _addPathCloser(path6, closer) {
+  _addPathCloser(path7, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path6);
+    let list = this._closers.get(path7);
     if (!list) {
       list = [];
-      this._closers.set(path6, list);
+      this._closers.set(path7, list);
     }
     list.push(closer);
   }
@@ -8071,7 +8281,7 @@ function watch(paths, options = {}) {
 var chokidar_default = { watch, FSWatcher };
 
 // src/core/watcher.ts
-import path6 from "node:path";
+import path7 from "node:path";
 function formatTime() {
   const now = new Date;
   const hours = String(now.getHours()).padStart(2, "0");
@@ -8104,7 +8314,7 @@ function getWatchPaths(operations) {
   return Array.from(paths);
 }
 async function handleFileChange(changedPath, state, options) {
-  const relPath = path6.relative(options.cwd || process.cwd(), changedPath);
+  const relPath = path7.relative(options.cwd || process.cwd(), changedPath);
   if (!logger.isSilent() && !options.verbose) {
     console.log(`[${formatTime()}] Changed: ${relPath}`);
   }
@@ -8118,9 +8328,9 @@ async function handleFileChange(changedPath, state, options) {
   for (const op of affectedOps) {
     const result = await performMerge(op);
     if (result.success && result.changed) {
-      const baseFile = op.basePath ? path6.basename(op.basePath) : "";
-      const machineFile = path6.basename(op.machinePath);
-      const outputFile = path6.basename(op.outputPath);
+      const baseFile = op.basePath ? path7.basename(op.basePath) : "";
+      const machineFile = path7.basename(op.machinePath);
+      const outputFile = path7.basename(op.outputPath);
       if (!logger.isSilent()) {
         if (baseFile) {
           console.log(`[${formatTime()}] Merged ${baseFile} + ${machineFile} → ${outputFile}`);
@@ -8131,7 +8341,7 @@ async function handleFileChange(changedPath, state, options) {
     } else if (!result.success && result.error) {
       logger.error(`Failed to merge: ${result.error.message}`);
     } else if (options.verbose && !result.changed) {
-      logger.info(`No changes needed for ${path6.basename(op.outputPath)}`);
+      logger.info(`No changes needed for ${path7.basename(op.outputPath)}`);
     }
   }
   if (!logger.isSilent() && !options.verbose) {
@@ -8162,7 +8372,7 @@ async function startWatcher(machineName, options = {}) {
   if (!logger.isSilent()) {
     console.log(`✓ Watching ${watchPaths.length} file(s) for changes...`);
     for (const watchPath of watchPaths) {
-      console.log(`  - ${path6.relative(cwd, watchPath)}`);
+      console.log(`  - ${path7.relative(cwd, watchPath)}`);
     }
     console.log("");
   }
@@ -8175,9 +8385,9 @@ async function startWatcher(machineName, options = {}) {
     }
   });
   watcher.on("change", (changedPath) => {
-    const absolutePath = path6.resolve(cwd, changedPath);
+    const absolutePath = path7.resolve(cwd, changedPath);
     if (options.verbose) {
-      logger.info(`File changed: ${path6.relative(cwd, absolutePath)}`);
+      logger.info(`File changed: ${path7.relative(cwd, absolutePath)}`);
     }
     const existingTimer = state.debounceTimers.get(absolutePath);
     if (existingTimer) {
@@ -8190,9 +8400,9 @@ async function startWatcher(machineName, options = {}) {
     state.debounceTimers.set(absolutePath, timer);
   });
   watcher.on("add", async (addedPath) => {
-    const absolutePath = path6.resolve(cwd, addedPath);
+    const absolutePath = path7.resolve(cwd, addedPath);
     if (options.verbose) {
-      logger.info(`File added: ${path6.relative(cwd, absolutePath)}`);
+      logger.info(`File added: ${path7.relative(cwd, absolutePath)}`);
     }
     const newOperations = await scanForMergeOperations(machineName, cwd);
     state.operations = newOperations;
@@ -8201,7 +8411,7 @@ async function startWatcher(machineName, options = {}) {
   });
   watcher.on("unlink", (deletedPath) => {
     if (options.verbose) {
-      const relPath = path6.relative(cwd, deletedPath);
+      const relPath = path7.relative(cwd, deletedPath);
       logger.warn(`File deleted: ${relPath}`);
       logger.info("Run merge manually or restart watch to update operations");
     }
@@ -8222,17 +8432,17 @@ async function startWatcher(machineName, options = {}) {
 }
 
 // src/cli.ts
-import fs3 from "node:fs/promises";
-import path7 from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+import fs4 from "node:fs/promises";
+import path8 from "node:path";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { createInterface } from "node:readline";
-var __filename2 = fileURLToPath3(import.meta.url);
-var __dirname2 = path7.dirname(__filename2);
+var __filename3 = fileURLToPath4(import.meta.url);
+var __dirname3 = path8.dirname(__filename3);
 async function checkExistingOutputFiles(operations) {
   const existing = [];
   for (const op of operations) {
     try {
-      await fs3.access(op.outputPath);
+      await fs4.access(op.outputPath);
       existing.push(op.outputPath);
     } catch {}
   }
@@ -8243,8 +8453,8 @@ async function checkTrackedOutputFiles(operations) {
   const cwd = process.cwd();
   for (const op of operations) {
     try {
-      await fs3.access(op.outputPath);
-      const relativePath = path7.relative(cwd, op.outputPath);
+      await fs4.access(op.outputPath);
+      const relativePath = path8.relative(cwd, op.outputPath);
       const isTracked = await isFileTrackedByGit(relativePath, cwd);
       if (isTracked) {
         tracked.push(op.outputPath);
@@ -8324,7 +8534,7 @@ async function handleInit(argv) {
       if (trackedFiles.length > 0 && !argv["no-gitignore"]) {
         logger.warn("⚠️  Warning: The following files will be overwritten and untracked from git:");
         for (const file of trackedFiles) {
-          logger.warn(`  - ${path7.relative(process.cwd(), file)}`);
+          logger.warn(`  - ${path8.relative(process.cwd(), file)}`);
         }
         logger.info("");
         const confirmed = argv.yes || await promptConfirmation("Do you want to continue?");
@@ -8392,7 +8602,7 @@ async function handleMerge(argv) {
       if (trackedFiles.length > 0) {
         logger.warn("⚠️  Warning: The following files will be overwritten and untracked from git:");
         for (const file of trackedFiles) {
-          logger.warn(`  - ${path7.relative(process.cwd(), file)}`);
+          logger.warn(`  - ${path8.relative(process.cwd(), file)}`);
         }
         logger.info("");
         const confirmed = argv.yes || await promptConfirmation("Do you want to continue?");
@@ -8430,11 +8640,11 @@ async function handleInfo(argv) {
     const operations = await scanForMergeOperations(machineName);
     console.log(`Machine name: ${machineName}`);
     console.log(`Repository: ${process.cwd()}`);
-    const { exec: exec2 } = await import("node:child_process");
-    const { promisify: promisify2 } = await import("node:util");
-    const execAsync2 = promisify2(exec2);
+    const { exec: exec3 } = await import("node:child_process");
+    const { promisify: promisify3 } = await import("node:util");
+    const execAsync3 = promisify3(exec3);
     try {
-      const { stdout } = await execAsync2("git config --get core.hooksPath");
+      const { stdout } = await execAsync3("git config --get core.hooksPath");
       const hooksPath = stdout.trim();
       if (hooksPath) {
         console.log(`Hooks method: core.hooksPath`);
@@ -8447,9 +8657,9 @@ async function handleInfo(argv) {
     }
     console.log(`Tracked patterns: ${operations.length}`);
     for (const op of operations) {
-      const baseName = op.basePath ? path7.basename(op.basePath) : "(none)";
-      const machineName2 = path7.basename(op.machinePath);
-      const outputName = path7.basename(op.outputPath);
+      const baseName = op.basePath ? path8.basename(op.basePath) : "(none)";
+      const machineName2 = path8.basename(op.machinePath);
+      const outputName = path8.basename(op.outputPath);
       console.log(`  - ${baseName} + ${machineName2} → ${outputName}`);
     }
     if (operations.length > 0) {
@@ -8459,7 +8669,7 @@ async function handleInfo(argv) {
       if (existingFiles.length > 0) {
         console.log("Existing output files:");
         for (const file of existingFiles) {
-          console.log(`  - ${path7.relative(process.cwd(), file)}`);
+          console.log(`  - ${path8.relative(process.cwd(), file)}`);
         }
       }
     }
@@ -8542,8 +8752,8 @@ DOCUMENTATION:
 }
 async function showVersion() {
   try {
-    const packageJsonPath = path7.join(__dirname2, "../package.json");
-    const packageJson = JSON.parse(await fs3.readFile(packageJsonPath, "utf-8"));
+    const packageJsonPath = path8.join(__dirname3, "../package.json");
+    const packageJson = JSON.parse(await fs4.readFile(packageJsonPath, "utf-8"));
     console.log(packageJson.version);
   } catch {
     console.log("unknown");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "permachine",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "Automatically merge machine-specific config files with base configs using git hooks",
   "type": "module",
   "bin": {