oh-my-customcode 0.1.0

package/dist/index.js

@@ -0,0 +1,927 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/core/installer.ts
+import { copyFile as fsCopyFile, rename } from "node:fs/promises";
+import { basename, join as join3 } from "node:path";
+
+// src/utils/fs.ts
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+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);
+  }
+}
+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 (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");
+}
+function getPackageRoot() {
+  const currentFile = fileURLToPath(import.meta.url);
+  const currentDir = dirname(currentFile);
+  return resolve(currentDir, "..", "..");
+}
+function resolveTemplatePath(relativePath) {
+  const packageRoot = getPackageRoot();
+  return join(packageRoot, "templates", relativePath);
+}
+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",
+  colors: true,
+  locale: "en",
+  timestamps: false
+};
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var COLORS = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  black: "\x1B[30m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  brightRed: "\x1B[91m",
+  brightGreen: "\x1B[92m",
+  brightYellow: "\x1B[93m",
+  brightBlue: "\x1B[94m",
+  brightMagenta: "\x1B[95m",
+  brightCyan: "\x1B[96m"
+};
+var LEVEL_COLORS = {
+  debug: COLORS.dim,
+  info: COLORS.blue,
+  warn: COLORS.yellow,
+  error: COLORS.red
+};
+var LEVEL_ICONS = {
+  debug: "\uD83D\uDD0D",
+  info: "ℹ️",
+  warn: "⚠️",
+  error: "❌"
+};
+var MESSAGES = {
+  en: {
+    "install.start": "Initializing oh-my-customcode...",
+    "install.success": "Successfully initialized!",
+    "install.failed": "Installation failed: {{error}}",
+    "install.exists": "Existing .claude/ directory found",
+    "install.backup": "Backed up existing files to: {{path}}",
+    "install.directories_created": "Directory structure created",
+    "install.component_skipped": "Skipped {{component}} (already exists)",
+    "install.component_installed": "Installed {{component}}",
+    "install.template_not_found": "Template not found for {{component}}: {{path}}",
+    "install.claude_md_installed": "CLAUDE.md installed ({{language}})",
+    "install.claude_md_not_found": "CLAUDE.md template not found for {{language}}",
+    "update.start": "Checking for updates...",
+    "update.success": "Updated from {{from}} to {{to}}",
+    "update.failed": "Update failed: {{error}}",
+    "update.no_updates": "Already up to date",
+    "update.backup_created": "Backup created at: {{path}}",
+    "update.dry_run": "Would update {{component}}",
+    "update.component_updated": "Updated {{component}}",
+    "update.file_applied": "Applied update to {{path}}",
+    "config.load_failed": "Failed to load config: {{error}}",
+    "config.not_found": "Config not found at {{path}}, using defaults",
+    "config.saved": "Config saved to {{path}}",
+    "config.deleted": "Config deleted from {{path}}",
+    "general.done": "Done!",
+    "general.failed": "Failed",
+    "general.skipped": "Skipped"
+  },
+  ko: {
+    "install.start": "oh-my-customcode 초기화 중...",
+    "install.success": "초기화 완료!",
+    "install.failed": "설치 실패: {{error}}",
+    "install.exists": "기존 .claude/ 디렉토리 발견",
+    "install.backup": "기존 파일 백업 완료: {{path}}",
+    "install.directories_created": "디렉토리 구조 생성 완료",
+    "install.component_skipped": "{{component}} 건너뜀 (이미 존재)",
+    "install.component_installed": "{{component}} 설치 완료",
+    "install.template_not_found": "{{component}} 템플릿 없음: {{path}}",
+    "install.claude_md_installed": "CLAUDE.md 설치 완료 ({{language}})",
+    "install.claude_md_not_found": "{{language}}용 CLAUDE.md 템플릿 없음",
+    "update.start": "업데이트 확인 중...",
+    "update.success": "{{from}}에서 {{to}}로 업데이트 완료",
+    "update.failed": "업데이트 실패: {{error}}",
+    "update.no_updates": "이미 최신 버전입니다",
+    "update.backup_created": "백업 생성됨: {{path}}",
+    "update.dry_run": "{{component}} 업데이트 예정",
+    "update.component_updated": "{{component}} 업데이트 완료",
+    "update.file_applied": "{{path}} 업데이트 적용",
+    "config.load_failed": "설정 로드 실패: {{error}}",
+    "config.not_found": "{{path}}에 설정 없음, 기본값 사용",
+    "config.saved": "설정 저장: {{path}}",
+    "config.deleted": "설정 삭제: {{path}}",
+    "general.done": "완료!",
+    "general.failed": "실패",
+    "general.skipped": "건너뜀"
+  }
+};
+function createLogger(options = {}) {
+  currentOptions = { ...currentOptions, ...options };
+}
+function setLogLevel(level) {
+  currentOptions.level = level;
+}
+function setLocale(locale) {
+  currentOptions.locale = locale;
+}
+function getMessage(key, params) {
+  const messages = MESSAGES[currentOptions.locale] || MESSAGES.en;
+  let message = messages[key] || key;
+  if (params) {
+    for (const [k, v] of Object.entries(params)) {
+      message = message.replace(new RegExp(`{{${k}}}`, "g"), v);
+    }
+  }
+  return message;
+}
+function formatMessage(level, message) {
+  const parts = [];
+  if (currentOptions.timestamps) {
+    const timestamp = new Date().toISOString().slice(11, 19);
+    if (currentOptions.colors) {
+      parts.push(`${COLORS.dim}[${timestamp}]${COLORS.reset}`);
+    } else {
+      parts.push(`[${timestamp}]`);
+    }
+  }
+  if (currentOptions.prefix) {
+    if (currentOptions.colors) {
+      parts.push(`${COLORS.cyan}[${currentOptions.prefix}]${COLORS.reset}`);
+    } else {
+      parts.push(`[${currentOptions.prefix}]`);
+    }
+  }
+  if (currentOptions.colors) {
+    const color = LEVEL_COLORS[level];
+    const icon = LEVEL_ICONS[level];
+    parts.push(`${color}${icon}${COLORS.reset}`);
+  } else {
+    parts.push(`[${level.toUpperCase()}]`);
+  }
+  if (currentOptions.colors && level === "error") {
+    parts.push(`${COLORS.red}${message}${COLORS.reset}`);
+  } else if (currentOptions.colors && level === "warn") {
+    parts.push(`${COLORS.yellow}${message}${COLORS.reset}`);
+  } else {
+    parts.push(message);
+  }
+  return parts.join(" ");
+}
+function shouldLog(level) {
+  return LOG_LEVELS[level] >= LOG_LEVELS[currentOptions.level];
+}
+function debug(messageKey, params) {
+  if (shouldLog("debug")) {
+    const message = getMessage(messageKey, params);
+    console.debug(formatMessage("debug", message));
+  }
+}
+function info(messageKey, params) {
+  if (shouldLog("info")) {
+    const message = getMessage(messageKey, params);
+    console.info(formatMessage("info", message));
+  }
+}
+function warn(messageKey, params) {
+  if (shouldLog("warn")) {
+    const message = getMessage(messageKey, params);
+    console.warn(formatMessage("warn", message));
+  }
+}
+function error(messageKey, params) {
+  if (shouldLog("error")) {
+    const message = getMessage(messageKey, params);
+    console.error(formatMessage("error", message));
+  }
+}
+function success(messageKey, params) {
+  if (shouldLog("info")) {
+    const message = getMessage(messageKey, params);
+    if (currentOptions.colors) {
+      console.info(`${COLORS.green}✓${COLORS.reset} ${message}`);
+    } else {
+      console.info(`[SUCCESS] ${message}`);
+    }
+  }
+}
+
+// src/core/config.ts
+import { join as join2 } from "node:path";
+var CONFIG_FILE = ".omccrc.json";
+var CURRENT_CONFIG_VERSION = 1;
+function getDefaultConfig() {
+  return {
+    configVersion: CURRENT_CONFIG_VERSION,
+    version: "0.0.0",
+    language: "en",
+    installedAt: "",
+    lastUpdated: "",
+    installedComponents: [],
+    componentVersions: {},
+    agents: {},
+    preferences: getDefaultPreferences(),
+    sourceRepo: "https://github.com/baekenough/baekgom-agents",
+    autoUpdate: {
+      enabled: false,
+      checkIntervalHours: 24,
+      autoApplyMinor: false
+    }
+  };
+}
+function getDefaultPreferences() {
+  return {
+    logLevel: "info",
+    colors: true,
+    showProgress: true,
+    confirmPrompts: true,
+    autoBackup: true
+  };
+}
+function getConfigPath(targetDir) {
+  return join2(targetDir, CONFIG_FILE);
+}
+async function loadConfig(targetDir) {
+  const configPath = getConfigPath(targetDir);
+  if (await fileExists(configPath)) {
+    try {
+      const config = await readJsonFile(configPath);
+      const merged = mergeConfig(getDefaultConfig(), config);
+      if (merged.configVersion < CURRENT_CONFIG_VERSION) {
+        const migrated = migrateConfig(merged);
+        await saveConfig(targetDir, migrated);
+        return migrated;
+      }
+      return merged;
+    } catch (err) {
+      warn("config.load_failed", { error: String(err) });
+      return getDefaultConfig();
+    }
+  }
+  debug("config.not_found", { path: configPath });
+  return getDefaultConfig();
+}
+async function saveConfig(targetDir, config) {
+  const configPath = getConfigPath(targetDir);
+  await ensureDirectory(targetDir);
+  config.lastUpdated = new Date().toISOString();
+  await writeJsonFile(configPath, config);
+  debug("config.saved", { path: configPath });
+}
+function mergeConfig(defaults, overrides) {
+  return {
+    ...defaults,
+    ...overrides,
+    preferences: overrides.preferences ? { ...defaults.preferences, ...overrides.preferences } : defaults.preferences,
+    autoUpdate: overrides.autoUpdate ? { ...defaults.autoUpdate, ...overrides.autoUpdate } : defaults.autoUpdate,
+    componentVersions: {
+      ...defaults.componentVersions,
+      ...overrides.componentVersions
+    },
+    agents: {
+      ...defaults.agents,
+      ...overrides.agents
+    }
+  };
+}
+function migrateConfig(config) {
+  const migrated = { ...config };
+  if (config.configVersion < 1) {
+    migrated.configVersion = 1;
+    migrated.preferences = getDefaultPreferences();
+    migrated.autoUpdate = {
+      enabled: false,
+      checkIntervalHours: 24,
+      autoApplyMinor: false
+    };
+  }
+  migrated.configVersion = CURRENT_CONFIG_VERSION;
+  return migrated;
+}
+
+// src/core/installer.ts
+var DIRECTORY_STRUCTURE = [
+  ".claude",
+  ".claude/rules",
+  ".claude/hooks",
+  ".claude/contexts",
+  "agents",
+  "agents/master",
+  "agents/orchestrator",
+  "agents/manager",
+  "agents/system",
+  "agents/sw-engineer",
+  "agents/sw-architect",
+  "agents/backend-engineer",
+  "agents/infra-engineer",
+  "agents/qa-engineer",
+  "agents/tutor",
+  "skills",
+  "skills/development",
+  "skills/backend",
+  "skills/infrastructure",
+  "skills/system",
+  "skills/orchestration",
+  "guides",
+  "pipelines",
+  "pipelines/templates",
+  "pipelines/examples",
+  "commands"
+];
+var COMPONENT_PATHS = {
+  "claude-md": "",
+  rules: ".claude/rules",
+  agents: "agents",
+  skills: "skills",
+  guides: "guides",
+  pipelines: "pipelines",
+  commands: "commands",
+  hooks: ".claude/hooks",
+  contexts: ".claude/contexts"
+};
+function getTemplateDir() {
+  const packageRoot = getPackageRoot();
+  return join3(packageRoot, "templates");
+}
+function createInstallResult(targetDir) {
+  return {
+    success: false,
+    installedPath: targetDir,
+    installedComponents: [],
+    skippedComponents: [],
+    backedUpPaths: [],
+    warnings: []
+  };
+}
+async function ensureTargetDirectory(targetDir) {
+  const targetExists = await fileExists(targetDir);
+  if (!targetExists) {
+    await ensureDirectory(targetDir);
+  }
+}
+async function handleBackup(targetDir, shouldBackup, result) {
+  if (!shouldBackup)
+    return;
+  const backupPaths = await backupExistingInstallation(targetDir);
+  result.backedUpPaths.push(...backupPaths);
+  if (backupPaths.length > 0) {
+    info("install.backup", { path: backupPaths[0] });
+  }
+}
+async function checkAndWarnExisting(targetDir, force, backup, result) {
+  if (force || backup)
+    return;
+  const existingPaths = await checkExistingPaths(targetDir);
+  if (existingPaths.length > 0) {
+    warn("install.exists");
+    result.warnings.push(`Existing files found: ${existingPaths.join(", ")}. Use --force to overwrite or --backup to backup first.`);
+  }
+}
+async function verifyTemplateDirectory() {
+  const templateDir = getTemplateDir();
+  if (!await fileExists(templateDir)) {
+    throw new Error(`Template directory not found: ${templateDir}`);
+  }
+}
+async function installAllComponents(targetDir, options, result) {
+  const components = options.components || getAllComponents();
+  for (const component of components) {
+    await installSingleComponent(targetDir, component, options, result);
+  }
+}
+async function installSingleComponent(targetDir, component, options, result) {
+  try {
+    const installed = await installComponent(targetDir, component, options);
+    if (installed) {
+      result.installedComponents.push(component);
+    } else {
+      result.skippedComponents.push(component);
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    result.warnings.push(`Failed to install ${component}: ${message}`);
+  }
+}
+async function installClaudeMdWithTracking(targetDir, options, result) {
+  const language = options.language || "en";
+  const overwrite = !!(options.force || options.backup);
+  const installed = await installClaudeMd(targetDir, language, overwrite);
+  if (installed) {
+    result.installedComponents.push("claude-md");
+  } else {
+    result.skippedComponents.push("claude-md");
+  }
+}
+async function updateInstallConfig(targetDir, options, installedComponents) {
+  const config = await loadConfig(targetDir);
+  config.language = options.language || "en";
+  config.installedAt = new Date().toISOString();
+  config.installedComponents = installedComponents;
+  await saveConfig(targetDir, config);
+}
+async function install(options) {
+  const result = createInstallResult(options.targetDir);
+  try {
+    info("install.start", { targetDir: options.targetDir });
+    await ensureTargetDirectory(options.targetDir);
+    await handleBackup(options.targetDir, !!options.backup, result);
+    await checkAndWarnExisting(options.targetDir, !!options.force, !!options.backup, result);
+    await verifyTemplateDirectory();
+    await createDirectoryStructure(options.targetDir);
+    debug("install.directories_created");
+    await installAllComponents(options.targetDir, options, result);
+    await installClaudeMdWithTracking(options.targetDir, options, result);
+    await updateInstallConfig(options.targetDir, options, result.installedComponents);
+    result.success = true;
+    success("install.success");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    result.error = message;
+    error("install.failed", { error: message });
+  }
+  return result;
+}
+async function copyTemplates(targetDir, templatePath, options) {
+  const srcPath = resolveTemplatePath(templatePath);
+  const destPath = join3(targetDir, templatePath);
+  await copyDirectory(srcPath, destPath, {
+    overwrite: options?.overwrite ?? false,
+    preserveSymlinks: options?.preserveSymlinks ?? true,
+    preserveTimestamps: true
+  });
+}
+async function createDirectoryStructure(targetDir) {
+  for (const dir of DIRECTORY_STRUCTURE) {
+    const fullPath = join3(targetDir, dir);
+    await ensureDirectory(fullPath);
+  }
+}
+async function getTemplateManifest() {
+  const packageRoot = getPackageRoot();
+  const manifestPath = join3(packageRoot, "templates", "manifest.json");
+  if (await fileExists(manifestPath)) {
+    return readJsonFile(manifestPath);
+  }
+  return {
+    version: "0.0.0",
+    lastUpdated: new Date().toISOString(),
+    components: getAllComponents().map((name) => ({
+      name,
+      path: COMPONENT_PATHS[name],
+      description: `${name} component`,
+      files: 0
+    })),
+    source: "https://github.com/baekenough/baekgom-agents"
+  };
+}
+function getAllComponents() {
+  return ["rules", "agents", "skills", "guides", "pipelines", "commands", "hooks", "contexts"];
+}
+async function installComponent(targetDir, component, options) {
+  const templatePath = COMPONENT_PATHS[component];
+  if (!templatePath) {
+    return false;
+  }
+  const destPath = join3(targetDir, templatePath);
+  const destExists = await fileExists(destPath);
+  if (destExists && !options.force && !options.backup) {
+    debug("install.component_skipped", { component });
+    return false;
+  }
+  const srcPath = resolveTemplatePath(templatePath);
+  if (!await fileExists(srcPath)) {
+    warn("install.template_not_found", { component, path: srcPath });
+    return false;
+  }
+  await copyDirectory(srcPath, destPath, {
+    overwrite: !!(options.force || options.backup),
+    preserveSymlinks: true,
+    preserveTimestamps: true
+  });
+  debug("install.component_installed", { component });
+  return true;
+}
+async function installClaudeMd(targetDir, language, overwrite = false) {
+  const templateFile = `CLAUDE.md.${language}`;
+  const srcPath = resolveTemplatePath(templateFile);
+  const destPath = join3(targetDir, "CLAUDE.md");
+  if (!await fileExists(srcPath)) {
+    warn("install.claude_md_not_found", { language, path: srcPath });
+    return false;
+  }
+  const destExists = await fileExists(destPath);
+  if (destExists && !overwrite) {
+    debug("install.claude_md_skipped", { reason: "exists", language });
+    return false;
+  }
+  await fsCopyFile(srcPath, destPath);
+  debug("install.claude_md_installed", { language });
+  return true;
+}
+async function backupExisting(sourcePath, backupDir) {
+  const name = basename(sourcePath);
+  const backupPath = join3(backupDir, name);
+  await rename(sourcePath, backupPath);
+  return backupPath;
+}
+async function checkExistingPaths(targetDir) {
+  const pathsToCheck = [
+    "CLAUDE.md",
+    ".claude",
+    "agents",
+    "skills",
+    "guides",
+    "pipelines",
+    "commands"
+  ];
+  const existingPaths = [];
+  for (const relativePath of pathsToCheck) {
+    const fullPath = join3(targetDir, relativePath);
+    if (await fileExists(fullPath)) {
+      existingPaths.push(relativePath);
+    }
+  }
+  return existingPaths;
+}
+async function backupExistingInstallation(targetDir) {
+  const existingPaths = await checkExistingPaths(targetDir);
+  if (existingPaths.length === 0) {
+    return [];
+  }
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const backupDir = join3(targetDir, `.claude-backup-${timestamp}`);
+  await ensureDirectory(backupDir);
+  const backedUpPaths = [];
+  for (const relativePath of existingPaths) {
+    const fullPath = join3(targetDir, relativePath);
+    try {
+      const backupPath = await backupExisting(fullPath, backupDir);
+      backedUpPaths.push(backupPath);
+      debug("install.backed_up", { from: relativePath, to: backupPath });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      warn("install.backup_failed", { path: relativePath, error: message });
+    }
+  }
+  return backedUpPaths.length > 0 ? [backupDir] : [];
+}
+// src/core/updater.ts
+import { join as join4 } from "node:path";
+var CUSTOMIZATION_MANIFEST_FILE = ".omcc-customizations.json";
+function createUpdateResult() {
+  return {
+    success: false,
+    updatedComponents: [],
+    skippedComponents: [],
+    preservedFiles: [],
+    backedUpPaths: [],
+    previousVersion: "",
+    newVersion: "",
+    warnings: []
+  };
+}
+async function handleBackupIfRequested(targetDir, backup, result) {
+  if (!backup)
+    return;
+  const backupPath = await backupInstallation(targetDir);
+  result.backedUpPaths.push(backupPath);
+  info("update.backup_created", { path: backupPath });
+}
+async function processComponentUpdate(targetDir, component, updateCheck, customizations, options, result) {
+  const componentUpdate = updateCheck.updatableComponents.find((c) => c.name === component);
+  if (!componentUpdate && !options.force) {
+    result.skippedComponents.push(component);
+    return;
+  }
+  if (options.dryRun) {
+    debug("update.dry_run", { component });
+    result.updatedComponents.push(component);
+    return;
+  }
+  try {
+    const preserved = await updateComponent(targetDir, component, customizations, options);
+    result.updatedComponents.push(component);
+    result.preservedFiles.push(...preserved);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    result.warnings.push(`Failed to update ${component}: ${message}`);
+    result.skippedComponents.push(component);
+  }
+}
+async function updateAllComponents(targetDir, components, updateCheck, customizations, options, result) {
+  for (const component of components) {
+    await processComponentUpdate(targetDir, component, updateCheck, customizations, options, result);
+  }
+}
+async function update(options) {
+  const result = createUpdateResult();
+  try {
+    info("update.start", { targetDir: options.targetDir });
+    const config = await loadConfig(options.targetDir);
+    result.previousVersion = config.version;
+    const updateCheck = await checkForUpdates(options.targetDir);
+    result.newVersion = updateCheck.latestVersion;
+    if (!updateCheck.hasUpdates && !options.force) {
+      info("update.no_updates");
+      result.success = true;
+      result.skippedComponents = options.components || getAllUpdateComponents();
+      return result;
+    }
+    await handleBackupIfRequested(options.targetDir, !!options.backup, result);
+    const customizations = options.preserveCustomizations !== false ? await loadCustomizationManifest(options.targetDir) : null;
+    const components = options.components || getAllUpdateComponents();
+    await updateAllComponents(options.targetDir, components, updateCheck, customizations, options, result);
+    config.version = result.newVersion;
+    config.lastUpdated = new Date().toISOString();
+    await saveConfig(options.targetDir, config);
+    result.success = true;
+    success("update.success", { from: result.previousVersion, to: result.newVersion });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    result.error = message;
+    error("update.failed", { error: message });
+  }
+  return result;
+}
+async function checkForUpdates(targetDir) {
+  const config = await loadConfig(targetDir);
+  const currentVersion = config.version;
+  const latestVersion = await getLatestVersion();
+  const updatableComponents = [];
+  for (const component of getAllUpdateComponents()) {
+    const hasUpdate = await componentHasUpdate(targetDir, component, config);
+    if (hasUpdate) {
+      updatableComponents.push({
+        name: component,
+        currentVersion: config.componentVersions?.[component] || "0.0.0",
+        latestVersion
+      });
+    }
+  }
+  return {
+    hasUpdates: updatableComponents.length > 0 || currentVersion !== latestVersion,
+    currentVersion,
+    latestVersion,
+    updatableComponents,
+    checkedAt: new Date().toISOString()
+  };
+}
+async function applyUpdates(targetDir, updates) {
+  const fs = await import("node:fs/promises");
+  for (const update2 of updates) {
+    const fullPath = join4(targetDir, update2.path);
+    await ensureDirectory(join4(fullPath, ".."));
+    await fs.writeFile(fullPath, update2.content, "utf-8");
+    debug("update.file_applied", { path: update2.path });
+  }
+}
+async function preserveCustomizations(targetDir, customizations) {
+  const preserved = new Map;
+  const fs = await import("node:fs/promises");
+  for (const filePath of customizations) {
+    const fullPath = join4(targetDir, filePath);
+    if (await fileExists(fullPath)) {
+      const content = await fs.readFile(fullPath, "utf-8");
+      preserved.set(filePath, content);
+    }
+  }
+  return preserved;
+}
+function getAllUpdateComponents() {
+  return ["rules", "agents", "skills", "guides", "pipelines", "commands", "hooks", "contexts"];
+}
+async function getLatestVersion() {
+  const manifestPath = resolveTemplatePath("manifest.json");
+  if (await fileExists(manifestPath)) {
+    const manifest = await readJsonFile(manifestPath);
+    return manifest.version;
+  }
+  return "0.0.0";
+}
+async function componentHasUpdate(targetDir, component, config) {
+  const installedVersion = config.componentVersions?.[component];
+  if (!installedVersion) {
+    return true;
+  }
+  const latestVersion = await getLatestVersion();
+  return installedVersion !== latestVersion;
+}
+async function updateComponent(targetDir, component, customizations, options) {
+  const preservedFiles = [];
+  const componentPath = getComponentPath(component);
+  const srcPath = resolveTemplatePath(componentPath);
+  const destPath = join4(targetDir, componentPath);
+  if (customizations && options.preserveCustomizations !== false) {
+    const toPreserve = customizations.preserveFiles.filter((f) => f.startsWith(componentPath));
+    if (toPreserve.length > 0) {
+      const preserved = await preserveCustomizations(targetDir, toPreserve);
+      preservedFiles.push(...preserved.keys());
+      await copyDirectory(srcPath, destPath, { overwrite: true });
+      const fs = await import("node:fs/promises");
+      for (const [path, content] of preserved) {
+        await fs.writeFile(join4(targetDir, path), content, "utf-8");
+      }
+    } else {
+      await copyDirectory(srcPath, destPath, { overwrite: true });
+    }
+  } else {
+    await copyDirectory(srcPath, destPath, { overwrite: true });
+  }
+  debug("update.component_updated", { component });
+  return preservedFiles;
+}
+function getComponentPath(component) {
+  const paths = {
+    rules: ".claude/rules",
+    agents: "agents",
+    skills: "skills",
+    guides: "guides",
+    pipelines: "pipelines",
+    commands: "commands",
+    hooks: ".claude/hooks",
+    contexts: ".claude/contexts"
+  };
+  return paths[component];
+}
+async function backupInstallation(targetDir) {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const backupDir = join4(targetDir, `.omcc-backup-${timestamp}`);
+  const fs = await import("node:fs/promises");
+  await ensureDirectory(backupDir);
+  const dirsToBackup = [".claude", "agents", "skills", "guides", "pipelines", "commands"];
+  for (const dir of dirsToBackup) {
+    const srcPath = join4(targetDir, dir);
+    if (await fileExists(srcPath)) {
+      const destPath = join4(backupDir, dir);
+      await copyDirectory(srcPath, destPath, { overwrite: true });
+    }
+  }
+  const claudeMdPath = join4(targetDir, "CLAUDE.md");
+  if (await fileExists(claudeMdPath)) {
+    await fs.copyFile(claudeMdPath, join4(backupDir, "CLAUDE.md"));
+  }
+  return backupDir;
+}
+async function loadCustomizationManifest(targetDir) {
+  const manifestPath = join4(targetDir, CUSTOMIZATION_MANIFEST_FILE);
+  if (await fileExists(manifestPath)) {
+    return readJsonFile(manifestPath);
+  }
+  return null;
+}
+
+// src/index.ts
+var VERSION = "0.0.0";
+var src_default = {
+  VERSION
+};
+export {
+  writeJsonFile,
+  warn,
+  update,
+  success,
+  setLogLevel,
+  setLocale,
+  saveConfig,
+  resolveTemplatePath,
+  readJsonFile,
+  preserveCustomizations,
+  mergeConfig,
+  loadConfig,
+  install,
+  info,
+  getTemplateManifest,
+  getPackageRoot,
+  getDefaultConfig,
+  getConfigPath,
+  fileExists,
+  error,
+  ensureDirectory,
+  src_default as default,
+  debug,
+  createLogger,
+  createDirectoryStructure,
+  copyTemplates,
+  copyDirectory,
+  checkForUpdates,
+  applyUpdates,
+  VERSION
+};