oh-my-customcode 0.24.2 → 0.30.1

package/dist/cli/index.js

@@ -31,6 +31,20 @@ var __toESM = (mod, isNodeMode, target) => {
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // node_modules/commander/lib/error.js
@@ -9028,6 +9042,281 @@ var require_public_api = __commonJS((exports) => {
   exports.stringify = stringify;
 });
 
+// src/utils/fs.ts
+var exports_fs = {};
+__export(exports_fs, {
+  writeTextFile: () => writeTextFile,
+  writeJsonFile: () => writeJsonFile,
+  validatePreserveFilePath: () => validatePreserveFilePath,
+  resolveTemplatePath: () => resolveTemplatePath,
+  resolvePath: () => resolvePath,
+  remove: () => remove,
+  readTextFile: () => readTextFile,
+  readJsonFile: () => readJsonFile,
+  normalizePath: () => normalizePath,
+  move: () => move,
+  listFiles: () => listFiles,
+  isAbsolutePath: () => isAbsolutePath,
+  getRelativePath: () => getRelativePath,
+  getPackageRoot: () => getPackageRoot,
+  getFileStats: () => getFileStats,
+  filesAreIdentical: () => filesAreIdentical,
+  fileExists: () => fileExists,
+  ensureDirectory: () => ensureDirectory,
+  createTempDir: () => createTempDir,
+  copyFile: () => copyFile,
+  copyDirectory: () => copyDirectory,
+  calculateChecksum: () => calculateChecksum
+});
+import { dirname as dirname2, isAbsolute, join as join2, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+function validatePreserveFilePath(filePath, projectRoot) {
+  if (!filePath || filePath.trim() === "") {
+    return {
+      valid: false,
+      reason: "Path cannot be empty"
+    };
+  }
+  if (isAbsolute(filePath)) {
+    return {
+      valid: false,
+      reason: "Absolute paths are not allowed"
+    };
+  }
+  const resolvedPath = resolve(projectRoot, filePath);
+  const relativePath = relative(projectRoot, resolvedPath);
+  if (relativePath.startsWith("..") || isAbsolute(relativePath)) {
+    return {
+      valid: false,
+      reason: "Path cannot traverse outside project root"
+    };
+  }
+  return { valid: true };
+}
+async function fileExists(path) {
+  const fs = await import("node:fs/promises");
+  try {
+    await fs.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureDirectory(path) {
+  const fs = await import("node:fs/promises");
+  await fs.mkdir(path, { recursive: true });
+}
+function shouldSkipEntry(entryName, options) {
+  if (options.exclude?.some((pattern) => matchesPattern(entryName, pattern))) {
+    return true;
+  }
+  if (options.include && !options.include.some((pattern) => matchesPattern(entryName, pattern))) {
+    return true;
+  }
+  return false;
+}
+async function handleSymlink(srcPath, destPath, options, fs) {
+  const destExists = await fileExists(destPath);
+  if (destExists && !options.overwrite) {
+    return;
+  }
+  if (options.preserveSymlinks !== false) {
+    await copyPreservedSymlink(srcPath, destPath, destExists, fs);
+  } else {
+    await copyFollowedSymlink(srcPath, destPath, destExists, options, fs);
+  }
+}
+async function copyPreservedSymlink(srcPath, destPath, destExists, fs) {
+  const linkTarget = await fs.readlink(srcPath);
+  if (destExists) {
+    await fs.unlink(destPath);
+  }
+  await fs.symlink(linkTarget, destPath);
+}
+async function copyFollowedSymlink(srcPath, destPath, destExists, options, fs) {
+  const realPath = await fs.realpath(srcPath);
+  const stat = await fs.stat(realPath);
+  if (stat.isDirectory()) {
+    await copyDirectory(realPath, destPath, options);
+    return;
+  }
+  if (destExists) {
+    await fs.unlink(destPath);
+  }
+  await fs.copyFile(realPath, destPath);
+}
+async function handleFile(srcPath, destPath, options, fs) {
+  const destExists = await fileExists(destPath);
+  if (destExists && !options.overwrite) {
+    return;
+  }
+  await fs.copyFile(srcPath, destPath);
+  if (options.preserveTimestamps) {
+    const stats = await fs.stat(srcPath);
+    await fs.utimes(destPath, stats.atime, stats.mtime);
+  }
+}
+function shouldSkipPath(destPath, destRoot, skipPaths) {
+  if (!skipPaths || skipPaths.length === 0) {
+    return false;
+  }
+  const relativePath = relative(destRoot, destPath);
+  for (const skipPath of skipPaths) {
+    if (skipPath.endsWith("/")) {
+      const dirPath = skipPath.slice(0, -1);
+      if (relativePath === dirPath || relativePath.startsWith(dirPath + sep)) {
+        return true;
+      }
+    } else {
+      if (relativePath === skipPath) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+async function copyDirectory(src, dest, options = {}) {
+  const fs = await import("node:fs/promises");
+  const path = await import("node:path");
+  await ensureDirectory(dest);
+  const entries = await fs.readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    if (shouldSkipEntry(entry.name, options)) {
+      continue;
+    }
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (shouldSkipPath(destPath, dest, options.skipPaths)) {
+      continue;
+    }
+    if (entry.isSymbolicLink()) {
+      await handleSymlink(srcPath, destPath, options, fs);
+    } else if (entry.isDirectory()) {
+      await copyDirectory(srcPath, destPath, options);
+    } else if (entry.isFile()) {
+      await handleFile(srcPath, destPath, options, fs);
+    }
+  }
+}
+async function readJsonFile(path) {
+  const fs = await import("node:fs/promises");
+  const content = await fs.readFile(path, "utf-8");
+  return JSON.parse(content);
+}
+async function writeJsonFile(path, data) {
+  const fs = await import("node:fs/promises");
+  const content = JSON.stringify(data, null, 2);
+  await fs.writeFile(path, content, "utf-8");
+}
+async function readTextFile(path) {
+  const fs = await import("node:fs/promises");
+  return fs.readFile(path, "utf-8");
+}
+async function writeTextFile(path, content) {
+  const fs = await import("node:fs/promises");
+  await ensureDirectory(dirname2(path));
+  await fs.writeFile(path, content, "utf-8");
+}
+async function remove(path) {
+  const fs = await import("node:fs/promises");
+  const stat = await fs.stat(path);
+  if (stat.isDirectory()) {
+    await fs.rm(path, { recursive: true, force: true });
+  } else {
+    await fs.unlink(path);
+  }
+}
+function getPackageRoot() {
+  const currentFile = fileURLToPath(import.meta.url);
+  const currentDir = dirname2(currentFile);
+  return resolve(currentDir, "..", "..");
+}
+function resolveTemplatePath(relativePath) {
+  const packageRoot = getPackageRoot();
+  return join2(packageRoot, "templates", relativePath);
+}
+async function listFiles(dir2, options = {}) {
+  const fs = await import("node:fs/promises");
+  const path = await import("node:path");
+  const files = [];
+  const entries = await fs.readdir(dir2, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir2, entry.name);
+    if (entry.isDirectory() && options.recursive) {
+      const subFiles = await listFiles(fullPath, options);
+      files.push(...subFiles);
+    } else if (entry.isFile()) {
+      if (!options.pattern || matchesPattern(entry.name, options.pattern)) {
+        files.push(fullPath);
+      }
+    }
+  }
+  return files;
+}
+async function getFileStats(path) {
+  const fs = await import("node:fs/promises");
+  const stats = await fs.stat(path);
+  return {
+    size: stats.size,
+    created: stats.birthtime,
+    modified: stats.mtime,
+    isDirectory: stats.isDirectory(),
+    isFile: stats.isFile()
+  };
+}
+async function copyFile(src, dest) {
+  const fs = await import("node:fs/promises");
+  await ensureDirectory(dirname2(dest));
+  await fs.copyFile(src, dest);
+}
+async function move(src, dest) {
+  const fs = await import("node:fs/promises");
+  await ensureDirectory(dirname2(dest));
+  await fs.rename(src, dest);
+}
+async function createTempDir(prefix = "omcustom-") {
+  const fs = await import("node:fs/promises");
+  const os = await import("node:os");
+  const path = await import("node:path");
+  const tempBase = os.tmpdir();
+  const tempDir = path.join(tempBase, `${prefix}${Date.now()}`);
+  await fs.mkdir(tempDir, { recursive: true });
+  return tempDir;
+}
+async function calculateChecksum(path) {
+  const fs = await import("node:fs/promises");
+  const crypto = await import("node:crypto");
+  const content = await fs.readFile(path);
+  const hash = crypto.createHash("md5");
+  hash.update(content);
+  return hash.digest("hex");
+}
+async function filesAreIdentical(path1, path2) {
+  const [checksum1, checksum2] = await Promise.all([
+    calculateChecksum(path1),
+    calculateChecksum(path2)
+  ]);
+  return checksum1 === checksum2;
+}
+function matchesPattern(filename, pattern) {
+  const regexPattern = pattern.replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".");
+  const regex = new RegExp(`^${regexPattern}$`);
+  return regex.test(filename);
+}
+function getRelativePath(basePath, fullPath) {
+  return relative(basePath, fullPath);
+}
+function normalizePath(inputPath) {
+  return inputPath.replace(/\\/g, "/");
+}
+function isAbsolutePath(inputPath) {
+  return isAbsolute(inputPath);
+}
+function resolvePath(...paths) {
+  return resolve(...paths);
+}
+var init_fs = () => {};
+
 // src/cli/index.ts
 import { createRequire as createRequire2 } from "node:module";
 
@@ -12626,196 +12915,9 @@ var $visit = visit.visit;
 var $visitAsync = visit.visitAsync;
 
 // src/core/config.ts
+init_fs();
 import { join as join3 } from "node:path";
 
-// src/utils/fs.ts
-import { dirname as dirname2, isAbsolute, join as join2, relative, resolve, sep } from "node:path";
-import { fileURLToPath } from "node:url";
-function validatePreserveFilePath(filePath, projectRoot) {
-  if (!filePath || filePath.trim() === "") {
-    return {
-      valid: false,
-      reason: "Path cannot be empty"
-    };
-  }
-  if (isAbsolute(filePath)) {
-    return {
-      valid: false,
-      reason: "Absolute paths are not allowed"
-    };
-  }
-  const resolvedPath = resolve(projectRoot, filePath);
-  const relativePath = relative(projectRoot, resolvedPath);
-  if (relativePath.startsWith("..") || isAbsolute(relativePath)) {
-    return {
-      valid: false,
-      reason: "Path cannot traverse outside project root"
-    };
-  }
-  return { valid: true };
-}
-async function fileExists(path) {
-  const fs = await import("node:fs/promises");
-  try {
-    await fs.access(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function ensureDirectory(path) {
-  const fs = await import("node:fs/promises");
-  await fs.mkdir(path, { recursive: true });
-}
-function shouldSkipEntry(entryName, options) {
-  if (options.exclude?.some((pattern) => matchesPattern(entryName, pattern))) {
-    return true;
-  }
-  if (options.include && !options.include.some((pattern) => matchesPattern(entryName, pattern))) {
-    return true;
-  }
-  return false;
-}
-async function handleSymlink(srcPath, destPath, options, fs) {
-  const destExists = await fileExists(destPath);
-  if (destExists && !options.overwrite) {
-    return;
-  }
-  if (options.preserveSymlinks !== false) {
-    await copyPreservedSymlink(srcPath, destPath, destExists, fs);
-  } else {
-    await copyFollowedSymlink(srcPath, destPath, destExists, options, fs);
-  }
-}
-async function copyPreservedSymlink(srcPath, destPath, destExists, fs) {
-  const linkTarget = await fs.readlink(srcPath);
-  if (destExists) {
-    await fs.unlink(destPath);
-  }
-  await fs.symlink(linkTarget, destPath);
-}
-async function copyFollowedSymlink(srcPath, destPath, destExists, options, fs) {
-  const realPath = await fs.realpath(srcPath);
-  const stat = await fs.stat(realPath);
-  if (stat.isDirectory()) {
-    await copyDirectory(realPath, destPath, options);
-    return;
-  }
-  if (destExists) {
-    await fs.unlink(destPath);
-  }
-  await fs.copyFile(realPath, destPath);
-}
-async function handleFile(srcPath, destPath, options, fs) {
-  const destExists = await fileExists(destPath);
-  if (destExists && !options.overwrite) {
-    return;
-  }
-  await fs.copyFile(srcPath, destPath);
-  if (options.preserveTimestamps) {
-    const stats = await fs.stat(srcPath);
-    await fs.utimes(destPath, stats.atime, stats.mtime);
-  }
-}
-function shouldSkipPath(destPath, destRoot, skipPaths) {
-  if (!skipPaths || skipPaths.length === 0) {
-    return false;
-  }
-  const relativePath = relative(destRoot, destPath);
-  for (const skipPath of skipPaths) {
-    if (skipPath.endsWith("/")) {
-      const dirPath = skipPath.slice(0, -1);
-      if (relativePath === dirPath || relativePath.startsWith(dirPath + sep)) {
-        return true;
-      }
-    } else {
-      if (relativePath === skipPath) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-async function copyDirectory(src, dest, options = {}) {
-  const fs = await import("node:fs/promises");
-  const path = await import("node:path");
-  await ensureDirectory(dest);
-  const entries = await fs.readdir(src, { withFileTypes: true });
-  for (const entry of entries) {
-    if (shouldSkipEntry(entry.name, options)) {
-      continue;
-    }
-    const srcPath = path.join(src, entry.name);
-    const destPath = path.join(dest, entry.name);
-    if (shouldSkipPath(destPath, dest, options.skipPaths)) {
-      continue;
-    }
-    if (entry.isSymbolicLink()) {
-      await handleSymlink(srcPath, destPath, options, fs);
-    } else if (entry.isDirectory()) {
-      await copyDirectory(srcPath, destPath, options);
-    } else if (entry.isFile()) {
-      await handleFile(srcPath, destPath, options, fs);
-    }
-  }
-}
-async function readJsonFile(path) {
-  const fs = await import("node:fs/promises");
-  const content = await fs.readFile(path, "utf-8");
-  return JSON.parse(content);
-}
-async function writeJsonFile(path, data) {
-  const fs = await import("node:fs/promises");
-  const content = JSON.stringify(data, null, 2);
-  await fs.writeFile(path, content, "utf-8");
-}
-async function readTextFile(path) {
-  const fs = await import("node:fs/promises");
-  return fs.readFile(path, "utf-8");
-}
-async function writeTextFile(path, content) {
-  const fs = await import("node:fs/promises");
-  await ensureDirectory(dirname2(path));
-  await fs.writeFile(path, content, "utf-8");
-}
-function getPackageRoot() {
-  const currentFile = fileURLToPath(import.meta.url);
-  const currentDir = dirname2(currentFile);
-  return resolve(currentDir, "..", "..");
-}
-function resolveTemplatePath(relativePath) {
-  const packageRoot = getPackageRoot();
-  return join2(packageRoot, "templates", relativePath);
-}
-async function listFiles(dir2, options = {}) {
-  const fs = await import("node:fs/promises");
-  const path = await import("node:path");
-  const files = [];
-  const entries = await fs.readdir(dir2, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path.join(dir2, entry.name);
-    if (entry.isDirectory() && options.recursive) {
-      const subFiles = await listFiles(fullPath, options);
-      files.push(...subFiles);
-    } else if (entry.isFile()) {
-      if (!options.pattern || matchesPattern(entry.name, options.pattern)) {
-        files.push(fullPath);
-      }
-    }
-  }
-  return files;
-}
-async function copyFile(src, dest) {
-  const fs = await import("node:fs/promises");
-  await ensureDirectory(dirname2(dest));
-  await fs.copyFile(src, dest);
-}
-function matchesPattern(filename, pattern) {
-  const regexPattern = pattern.replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".");
-  const regex = new RegExp(`^${regexPattern}$`);
-  return regex.test(filename);
-}
-
 // src/utils/logger.ts
 var currentOptions = {
   level: "info",
@@ -13026,7 +13128,12 @@ function getDefaultConfig() {
       checkIntervalHours: 24,
       autoApplyMinor: false
     },
-    preserveFiles: [],
+    preserveFiles: [
+      ".claude/settings.json",
+      ".claude/settings.local.json",
+      ".claude/agent-memory/",
+      ".claude/agent-memory-local/"
+    ],
     customComponents: []
   };
 }
@@ -13670,11 +13777,141 @@ async function doctorCommand(options = {}) {
 }
 
 // src/cli/init.ts
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 
 // src/core/installer.ts
+init_fs();
 import { readFile as fsReadFile, writeFile as fsWriteFile, rename } from "node:fs/promises";
+import { basename as basename2, join as join5 } from "node:path";
+
+// src/core/file-preservation.ts
+init_fs();
 import { basename, join as join4 } from "node:path";
+var DEFAULT_CRITICAL_FILES = ["settings.json", "settings.local.json"];
+var DEFAULT_CRITICAL_DIRECTORIES = ["agent-memory", "agent-memory-local"];
+async function extractSingleFile(fileName, rootDir, tempDir, result) {
+  const srcPath = join4(rootDir, fileName);
+  const destPath = join4(tempDir, fileName);
+  try {
+    if (await fileExists(srcPath)) {
+      await copyFile(srcPath, destPath);
+      result.extractedFiles.push(fileName);
+      debug("preserve.extracted_file", { file: fileName });
+    }
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    result.failures.push({ path: fileName, reason });
+    warn("preserve.extract_failed", { file: fileName, error: reason });
+  }
+}
+async function extractSingleDir(dirName, rootDir, tempDir, result) {
+  const srcPath = join4(rootDir, dirName);
+  const destPath = join4(tempDir, dirName);
+  try {
+    if (await fileExists(srcPath)) {
+      await copyDirectory(srcPath, destPath, { overwrite: true, preserveTimestamps: true });
+      result.extractedDirs.push(dirName);
+      debug("preserve.extracted_dir", { dir: dirName });
+    }
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    result.failures.push({ path: dirName, reason });
+    warn("preserve.extract_dir_failed", { dir: dirName, error: reason });
+  }
+}
+async function extractCriticalFiles(rootDir, tempDir, additionalFiles = []) {
+  const result = {
+    tempDir,
+    extractedFiles: [],
+    extractedDirs: [],
+    failures: []
+  };
+  await ensureDirectory(tempDir);
+  const filesToExtract = [...DEFAULT_CRITICAL_FILES, ...additionalFiles];
+  for (const fileName of filesToExtract) {
+    await extractSingleFile(fileName, rootDir, tempDir, result);
+  }
+  for (const dirName of DEFAULT_CRITICAL_DIRECTORIES) {
+    await extractSingleDir(dirName, rootDir, tempDir, result);
+  }
+  return result;
+}
+async function restoreCriticalFiles(rootDir, preservation) {
+  const result = {
+    restoredFiles: [],
+    restoredDirs: [],
+    failures: []
+  };
+  for (const fileName of preservation.extractedFiles) {
+    const preservedPath = join4(preservation.tempDir, fileName);
+    const targetPath = join4(rootDir, fileName);
+    try {
+      if (fileName.endsWith(".json")) {
+        await mergeJsonFile(preservedPath, targetPath);
+      } else {
+        await copyFile(preservedPath, targetPath);
+      }
+      result.restoredFiles.push(fileName);
+      debug("preserve.restored_file", { file: fileName });
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      result.failures.push({ path: fileName, reason });
+      warn("preserve.restore_failed", { file: fileName, error: reason });
+    }
+  }
+  for (const dirName of preservation.extractedDirs) {
+    const preservedPath = join4(preservation.tempDir, dirName);
+    const targetPath = join4(rootDir, dirName);
+    try {
+      await copyDirectory(preservedPath, targetPath, {
+        overwrite: false,
+        preserveTimestamps: true
+      });
+      result.restoredDirs.push(dirName);
+      debug("preserve.restored_dir", { dir: dirName });
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      result.failures.push({ path: dirName, reason });
+      warn("preserve.restore_dir_failed", { dir: dirName, error: reason });
+    }
+  }
+  return result;
+}
+async function mergeJsonFile(preservedPath, targetPath) {
+  const preservedData = await readJsonFile(preservedPath);
+  if (await fileExists(targetPath)) {
+    const targetData = await readJsonFile(targetPath);
+    const merged = deepMerge(targetData, preservedData);
+    await writeJsonFile(targetPath, merged);
+    debug("preserve.merged_json", { file: basename(targetPath) });
+  } else {
+    await copyFile(preservedPath, targetPath);
+    debug("preserve.copied_json", { file: basename(targetPath) });
+  }
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceVal = source[key];
+    const targetVal = result[key];
+    if (sourceVal !== null && typeof sourceVal === "object" && !Array.isArray(sourceVal) && targetVal !== null && typeof targetVal === "object" && !Array.isArray(targetVal)) {
+      result[key] = deepMerge(targetVal, sourceVal);
+    } else {
+      result[key] = sourceVal;
+    }
+  }
+  return result;
+}
+async function cleanupPreservation(tempDir) {
+  try {
+    const { rm } = await import("node:fs/promises");
+    await rm(tempDir, { recursive: true, force: true });
+    debug("preserve.cleanup", { dir: tempDir });
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    warn("preserve.cleanup_failed", { dir: tempDir, error: reason });
+  }
+}
 
 // src/core/git-workflow.ts
 import { execFileSync } from "node:child_process";
@@ -13927,7 +14164,7 @@ function getDefaultWorkflow() {
 var DEFAULT_LANGUAGE2 = "en";
 function getTemplateDir() {
   const packageRoot = getPackageRoot();
-  return join4(packageRoot, "templates");
+  return join5(packageRoot, "templates");
 }
 function createInstallResult(targetDir) {
   return {
@@ -13947,12 +14184,27 @@ async function ensureTargetDirectory(targetDir) {
 }
 async function handleBackup(targetDir, shouldBackup, result) {
   if (!shouldBackup)
-    return;
+    return null;
+  const layout = getProviderLayout();
+  const rootDir = join5(targetDir, layout.rootDir);
+  let preservation = null;
+  if (await fileExists(rootDir)) {
+    const { createTempDir: createTempDir2 } = await Promise.resolve().then(() => (init_fs(), exports_fs));
+    const tempDir = await createTempDir2("omcustom-preserve-");
+    preservation = await extractCriticalFiles(rootDir, tempDir);
+    if (preservation.extractedFiles.length > 0 || preservation.extractedDirs.length > 0) {
+      info("install.preserved", {
+        files: String(preservation.extractedFiles.length),
+        dirs: String(preservation.extractedDirs.length)
+      });
+    }
+  }
   const backupPaths = await backupExistingInstallation(targetDir);
   result.backedUpPaths.push(...backupPaths);
   if (backupPaths.length > 0) {
     info("install.backup", { path: backupPaths[0] });
   }
+  return preservation;
 }
 async function checkAndWarnExisting(targetDir, force, backup, result) {
   if (force || backup)
@@ -13991,8 +14243,8 @@ async function installSingleComponent(targetDir, component, options, result) {
 }
 async function installStatusline(targetDir, options, _result) {
   const layout = getProviderLayout();
-  const srcPath = resolveTemplatePath(join4(layout.rootDir, "statusline.sh"));
-  const destPath = join4(targetDir, layout.rootDir, "statusline.sh");
+  const srcPath = resolveTemplatePath(join5(layout.rootDir, "statusline.sh"));
+  const destPath = join5(targetDir, layout.rootDir, "statusline.sh");
   if (!await fileExists(srcPath)) {
     debug("install.statusline_not_found", { path: srcPath });
     return;
@@ -14010,7 +14262,7 @@ async function installStatusline(targetDir, options, _result) {
 }
 async function installSettingsLocal(targetDir, result) {
   const layout = getProviderLayout();
-  const settingsPath = join4(targetDir, layout.rootDir, "settings.local.json");
+  const settingsPath = join5(targetDir, layout.rootDir, "settings.local.json");
   const statusLineConfig = {
     statusLine: {
       type: "command",
@@ -14058,13 +14310,30 @@ async function install(options) {
   try {
     info("install.start", { targetDir: options.targetDir });
     await ensureTargetDirectory(options.targetDir);
-    await handleBackup(options.targetDir, !!options.backup, result);
+    const preservation = await handleBackup(options.targetDir, !!options.backup, result);
     await checkAndWarnExisting(options.targetDir, !!options.force, !!options.backup, result);
     await verifyTemplateDirectory();
     await installAllComponents(options.targetDir, options, result);
     await installStatusline(options.targetDir, options, result);
     await installSettingsLocal(options.targetDir, result);
     await installEntryDocWithTracking(options.targetDir, options, result);
+    if (preservation) {
+      const layout = getProviderLayout();
+      const rootDir = join5(options.targetDir, layout.rootDir);
+      const restoration = await restoreCriticalFiles(rootDir, preservation);
+      if (restoration.restoredFiles.length > 0 || restoration.restoredDirs.length > 0) {
+        info("install.restored", {
+          files: String(restoration.restoredFiles.length),
+          dirs: String(restoration.restoredDirs.length)
+        });
+      }
+      if (restoration.failures.length > 0) {
+        for (const failure of restoration.failures) {
+          result.warnings.push(`Failed to restore ${failure.path}: ${failure.reason}`);
+        }
+      }
+      await cleanupPreservation(preservation.tempDir);
+    }
     await updateInstallConfig(options.targetDir, options, result.installedComponents);
     result.success = true;
     success("install.success");
@@ -14083,7 +14352,7 @@ async function installComponent(targetDir, component, options) {
     return false;
   }
   const templatePath = getComponentPath(component);
-  const destPath = join4(targetDir, templatePath);
+  const destPath = join5(targetDir, templatePath);
   const destExists = await fileExists(destPath);
   if (destExists && !options.force && !options.backup) {
     debug("install.component_skipped", { component });
@@ -14111,7 +14380,7 @@ async function installEntryDoc(targetDir, language, overwrite = false) {
   const layout = getProviderLayout();
   const templateFile = getEntryTemplateName(language);
   const srcPath = resolveTemplatePath(templateFile);
-  const destPath = join4(targetDir, layout.entryFile);
+  const destPath = join5(targetDir, layout.entryFile);
   if (!await fileExists(srcPath)) {
     warn("install.entry_md_not_found", { language, path: srcPath, entry: layout.entryFile });
     return false;
@@ -14131,8 +14400,8 @@ async function installEntryDoc(targetDir, language, overwrite = false) {
   return true;
 }
 async function backupExisting(sourcePath, backupDir) {
-  const name = basename(sourcePath);
-  const backupPath = join4(backupDir, name);
+  const name = basename2(sourcePath);
+  const backupPath = join5(backupDir, name);
   await rename(sourcePath, backupPath);
   return backupPath;
 }
@@ -14141,7 +14410,7 @@ async function checkExistingPaths(targetDir) {
   const pathsToCheck = [layout.entryFile, layout.rootDir, "guides"];
   const existingPaths = [];
   for (const relativePath of pathsToCheck) {
-    const fullPath = join4(targetDir, relativePath);
+    const fullPath = join5(targetDir, relativePath);
     if (await fileExists(fullPath)) {
       existingPaths.push(relativePath);
     }
@@ -14155,11 +14424,11 @@ async function backupExistingInstallation(targetDir) {
     return [];
   }
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-  const backupDir = join4(targetDir, `${layout.backupDirPrefix}${timestamp}`);
+  const backupDir = join5(targetDir, `${layout.backupDirPrefix}${timestamp}`);
   await ensureDirectory(backupDir);
   const backedUpPaths = [];
   for (const relativePath of existingPaths) {
-    const fullPath = join4(targetDir, relativePath);
+    const fullPath = join5(targetDir, relativePath);
     try {
       const backupPath = await backupExisting(fullPath, backupDir);
       backedUpPaths.push(backupPath);
@@ -14173,14 +14442,15 @@ async function backupExistingInstallation(targetDir) {
 }
 
 // src/core/mcp-config.ts
+init_fs();
 import { execSync as execSync3 } from "node:child_process";
 import { writeFile } from "node:fs/promises";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 async function generateMCPConfig(targetDir) {
   const layout = getProviderLayout();
-  const mcpConfigPath = join5(targetDir, ".mcp.json");
-  const ontologyDir = join5(layout.rootDir, "ontology");
-  const ontologyExists = await fileExists(join5(targetDir, ontologyDir));
+  const mcpConfigPath = join6(targetDir, ".mcp.json");
+  const ontologyDir = join6(layout.rootDir, "ontology");
+  const ontologyExists = await fileExists(join6(targetDir, ontologyDir));
   if (!ontologyExists) {
     return;
   }
@@ -14234,9 +14504,10 @@ async function checkUvAvailable() {
 }
 
 // src/cli/init.ts
+init_fs();
 async function checkExistingInstallation(targetDir) {
   const layout = getProviderLayout();
-  const rootDir = join6(targetDir, layout.rootDir);
+  const rootDir = join7(targetDir, layout.rootDir);
   return fileExists(rootDir);
 }
 var PROVIDER_SUBDIR_COMPONENTS = new Set([
@@ -14250,13 +14521,13 @@ var PROVIDER_SUBDIR_COMPONENTS = new Set([
 function componentToPath(targetDir, component) {
   if (component === "entry-md") {
     const layout = getProviderLayout();
-    return join6(targetDir, layout.entryFile);
+    return join7(targetDir, layout.entryFile);
   }
   if (PROVIDER_SUBDIR_COMPONENTS.has(component)) {
     const layout = getProviderLayout();
-    return join6(targetDir, layout.rootDir, component);
+    return join7(targetDir, layout.rootDir, component);
   }
-  return join6(targetDir, component);
+  return join7(targetDir, component);
 }
 function buildInstalledPaths(targetDir, components) {
   return components.map((component) => componentToPath(targetDir, component));
@@ -14336,7 +14607,8 @@ async function initCommand(options) {
 }
 
 // src/cli/list.ts
-import { basename as basename2, dirname as dirname3, join as join7, relative as relative2 } from "node:path";
+import { basename as basename3, dirname as dirname3, join as join8, relative as relative2 } from "node:path";
+init_fs();
 var ALLOWED_TOP_LEVEL_KEYS = new Set(["name", "type", "description", "version", "category"]);
 function parseKeyValue(line) {
   const colonIndex = line.indexOf(":");
@@ -14382,7 +14654,7 @@ function parseYamlMetadata(content) {
   return result;
 }
 function extractAgentTypeFromFilename(filename) {
-  const name = basename2(filename, ".md");
+  const name = basename3(filename, ".md");
   const prefixMap = {
     lang: "language",
     be: "backend",
@@ -14400,17 +14672,17 @@ function extractAgentTypeFromFilename(filename) {
   return prefixMap[prefix] || "unknown";
 }
 function extractSkillCategoryFromPath(skillPath, baseDir, rootDir) {
-  const relativePath = relative2(join7(baseDir, rootDir, "skills"), skillPath);
+  const relativePath = relative2(join8(baseDir, rootDir, "skills"), skillPath);
   const parts = relativePath.split("/").filter(Boolean);
   return parts[0] || "unknown";
 }
 function extractGuideCategoryFromPath(guidePath, baseDir) {
-  const relativePath = relative2(join7(baseDir, "guides"), guidePath);
+  const relativePath = relative2(join8(baseDir, "guides"), guidePath);
   const parts = relativePath.split("/").filter(Boolean);
   return parts[0] || "unknown";
 }
 function extractRulePriorityFromFilename(filename) {
-  const name = basename2(filename, ".md");
+  const name = basename3(filename, ".md");
   const parts = name.split("-");
   return parts[0] || "unknown";
 }
@@ -14499,7 +14771,7 @@ async function tryExtractMarkdownDescription(mdPath, options = {}) {
   }
 }
 async function getAgents(targetDir, rootDir = ".claude", config) {
-  const agentsDir = join7(targetDir, rootDir, "agents");
+  const agentsDir = join8(targetDir, rootDir, "agents");
   if (!await fileExists(agentsDir))
     return [];
   try {
@@ -14508,8 +14780,8 @@ async function getAgents(targetDir, rootDir = ".claude", config) {
     const customAgentPaths = new Set(customComponents.filter((c) => c.type === "agent").map((c) => c.path));
     const agentMdFiles = await listFiles(agentsDir, { recursive: false, pattern: "*.md" });
     const agents = await Promise.all(agentMdFiles.map(async (agentMdPath) => {
-      const filename = basename2(agentMdPath);
-      const name = basename2(filename, ".md");
+      const filename = basename3(agentMdPath);
+      const name = basename3(filename, ".md");
       const description = await tryExtractMarkdownDescription(agentMdPath);
       const relativePath = relative2(targetDir, agentMdPath);
       return {
@@ -14527,7 +14799,7 @@ async function getAgents(targetDir, rootDir = ".claude", config) {
   }
 }
 async function getSkills(targetDir, rootDir = ".claude", config) {
-  const skillsDir = join7(targetDir, rootDir, "skills");
+  const skillsDir = join8(targetDir, rootDir, "skills");
   if (!await fileExists(skillsDir))
     return [];
   try {
@@ -14537,11 +14809,11 @@ async function getSkills(targetDir, rootDir = ".claude", config) {
     const skillMdFiles = await listFiles(skillsDir, { recursive: true, pattern: "SKILL.md" });
     const skills = await Promise.all(skillMdFiles.map(async (skillMdPath) => {
       const skillDir = dirname3(skillMdPath);
-      const indexYamlPath = join7(skillDir, "index.yaml");
+      const indexYamlPath = join8(skillDir, "index.yaml");
       const { description, version } = await tryReadIndexYamlMetadata(indexYamlPath);
       const relativePath = relative2(targetDir, skillDir);
       return {
-        name: basename2(skillDir),
+        name: basename3(skillDir),
         type: "skill",
         category: extractSkillCategoryFromPath(skillDir, targetDir, rootDir),
         path: relativePath,
@@ -14556,7 +14828,7 @@ async function getSkills(targetDir, rootDir = ".claude", config) {
   }
 }
 async function getGuides(targetDir, config) {
-  const guidesDir = join7(targetDir, "guides");
+  const guidesDir = join8(targetDir, "guides");
   if (!await fileExists(guidesDir))
     return [];
   try {
@@ -14568,7 +14840,7 @@ async function getGuides(targetDir, config) {
       const description = await tryExtractMarkdownDescription(guideMdPath, { maxLength: 100 });
       const relativePath = relative2(targetDir, guideMdPath);
       return {
-        name: basename2(guideMdPath, ".md"),
+        name: basename3(guideMdPath, ".md"),
         type: "guide",
         category: extractGuideCategoryFromPath(guideMdPath, targetDir),
         path: relativePath,
@@ -14583,7 +14855,7 @@ async function getGuides(targetDir, config) {
 }
 var RULE_PRIORITY_ORDER = { MUST: 0, SHOULD: 1, MAY: 2 };
 async function getRules(targetDir, rootDir = ".claude", config) {
-  const rulesDir = join7(targetDir, rootDir, "rules");
+  const rulesDir = join8(targetDir, rootDir, "rules");
   if (!await fileExists(rulesDir))
     return [];
   try {
@@ -14592,13 +14864,13 @@ async function getRules(targetDir, rootDir = ".claude", config) {
     const customRulePaths = new Set(customComponents.filter((c) => c.type === "rule").map((c) => c.path));
     const ruleMdFiles = await listFiles(rulesDir, { recursive: false, pattern: "*.md" });
     const rules = await Promise.all(ruleMdFiles.map(async (ruleMdPath) => {
-      const filename = basename2(ruleMdPath);
+      const filename = basename3(ruleMdPath);
       const description = await tryExtractMarkdownDescription(ruleMdPath, {
         cleanFormatting: true
       });
       const relativePath = relative2(targetDir, ruleMdPath);
       return {
-        name: basename2(ruleMdPath, ".md"),
+        name: basename3(ruleMdPath, ".md"),
         type: extractRulePriorityFromFilename(filename),
         path: relativePath,
         description,
@@ -14655,7 +14927,7 @@ function formatAsJson(components) {
   console.log(JSON.stringify(components, null, 2));
 }
 async function getHooks(targetDir, rootDir = ".claude") {
-  const hooksDir = join7(targetDir, rootDir, "hooks");
+  const hooksDir = join8(targetDir, rootDir, "hooks");
   if (!await fileExists(hooksDir))
     return [];
   try {
@@ -14664,7 +14936,7 @@ async function getHooks(targetDir, rootDir = ".claude") {
     const hookYamls = await listFiles(hooksDir, { recursive: true, pattern: "*.yaml" });
     const allFiles = [...hookFiles, ...hookConfigs, ...hookYamls];
     return allFiles.map((hookPath) => ({
-      name: basename2(hookPath),
+      name: basename3(hookPath),
       type: "hook",
       path: relative2(targetDir, hookPath)
     })).sort((a, b) => a.name.localeCompare(b.name));
@@ -14673,7 +14945,7 @@ async function getHooks(targetDir, rootDir = ".claude") {
   }
 }
 async function getContexts(targetDir, rootDir = ".claude") {
-  const contextsDir = join7(targetDir, rootDir, "contexts");
+  const contextsDir = join8(targetDir, rootDir, "contexts");
   if (!await fileExists(contextsDir))
     return [];
   try {
@@ -14684,7 +14956,7 @@ async function getContexts(targetDir, rootDir = ".claude") {
       const ext = ctxPath.endsWith(".md") ? ".md" : ".yaml";
       const description = ext === ".md" ? await tryExtractMarkdownDescription(ctxPath, { maxLength: 100 }) : undefined;
       return {
-        name: basename2(ctxPath, ext),
+        name: basename3(ctxPath, ext),
         type: "context",
         path: relative2(targetDir, ctxPath),
         description
@@ -15062,7 +15334,8 @@ async function securityCommand(_options = {}) {
 }
 
 // src/core/updater.ts
-import { join as join8 } from "node:path";
+init_fs();
+import { join as join9 } from "node:path";
 
 // src/core/entry-merger.ts
 var MANAGED_START = "<!-- omcustom:start -->";
@@ -15311,7 +15584,7 @@ function resolveCustomizations(customizations, configPreserveFiles, targetDir) {
 }
 async function updateEntryDoc(targetDir, config, options) {
   const layout = getProviderLayout();
-  const entryPath = join8(targetDir, layout.entryFile);
+  const entryPath = join9(targetDir, layout.entryFile);
   const templateName = getEntryTemplateName2(config.language);
   const templatePath = resolveTemplatePath(templateName);
   if (!await fileExists(templatePath)) {
@@ -15445,7 +15718,7 @@ async function updateComponent(targetDir, component, customizations, options, co
   const preservedFiles = [];
   const componentPath = getComponentPath2(component);
   const srcPath = resolveTemplatePath(componentPath);
-  const destPath = join8(targetDir, componentPath);
+  const destPath = join9(targetDir, componentPath);
   const customComponents = config.customComponents || [];
   const skipPaths = [];
   if (customizations && !options.forceOverwriteAll) {
@@ -15459,7 +15732,7 @@ async function updateComponent(targetDir, component, customizations, options, co
     }
   }
   const path3 = await import("node:path");
-  const normalizedSkipPaths = skipPaths.map((p) => path3.relative(destPath, join8(targetDir, p)));
+  const normalizedSkipPaths = skipPaths.map((p) => path3.relative(destPath, join9(targetDir, p)));
   await copyDirectory(srcPath, destPath, {
     overwrite: true,
     skipPaths: normalizedSkipPaths.length > 0 ? normalizedSkipPaths : undefined
@@ -15479,12 +15752,12 @@ async function syncRootLevelFiles(targetDir, options) {
   const layout = getProviderLayout();
   const synced = [];
   for (const fileName of ROOT_LEVEL_FILES) {
-    const srcPath = resolveTemplatePath(join8(layout.rootDir, fileName));
+    const srcPath = resolveTemplatePath(join9(layout.rootDir, fileName));
     if (!await fileExists(srcPath)) {
       continue;
     }
-    const destPath = join8(targetDir, layout.rootDir, fileName);
-    await ensureDirectory(join8(destPath, ".."));
+    const destPath = join9(targetDir, layout.rootDir, fileName);
+    await ensureDirectory(join9(destPath, ".."));
     await fs3.copyFile(srcPath, destPath);
     if (fileName.endsWith(".sh")) {
       await fs3.chmod(destPath, 493);
@@ -15519,7 +15792,7 @@ async function removeDeprecatedFiles(targetDir, options) {
       });
       continue;
     }
-    const fullPath = join8(targetDir, entry.path);
+    const fullPath = join9(targetDir, entry.path);
     if (await fileExists(fullPath)) {
       await fs3.unlink(fullPath);
       removed.push(entry.path);
@@ -15543,26 +15816,26 @@ function getComponentPath2(component) {
 }
 async function backupInstallation(targetDir) {
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-  const backupDir = join8(targetDir, `.omcustom-backup-${timestamp}`);
+  const backupDir = join9(targetDir, `.omcustom-backup-${timestamp}`);
   const fs3 = await import("node:fs/promises");
   await ensureDirectory(backupDir);
   const layout = getProviderLayout();
   const dirsToBackup = [layout.rootDir, "guides"];
   for (const dir2 of dirsToBackup) {
-    const srcPath = join8(targetDir, dir2);
+    const srcPath = join9(targetDir, dir2);
     if (await fileExists(srcPath)) {
-      const destPath = join8(backupDir, dir2);
+      const destPath = join9(backupDir, dir2);
       await copyDirectory(srcPath, destPath, { overwrite: true });
     }
   }
-  const entryPath = join8(targetDir, layout.entryFile);
+  const entryPath = join9(targetDir, layout.entryFile);
   if (await fileExists(entryPath)) {
-    await fs3.copyFile(entryPath, join8(backupDir, layout.entryFile));
+    await fs3.copyFile(entryPath, join9(backupDir, layout.entryFile));
   }
   return backupDir;
 }
 async function loadCustomizationManifest(targetDir) {
-  const manifestPath = join8(targetDir, CUSTOMIZATION_MANIFEST_FILE);
+  const manifestPath = join9(targetDir, CUSTOMIZATION_MANIFEST_FILE);
   if (await fileExists(manifestPath)) {
     return readJsonFile(manifestPath);
   }