oh-my-customcode 0.9.1 → 0.9.3

package/README.md

@@ -16,7 +16,7 @@ Like oh-my-zsh transformed shell customization, oh-my-customcode makes personali
 
 | Feature | Description |
 |---------|-------------|
-| **Batteries Included** | 42 agents, 51 skills, 22 guides, 18 rules, 1 hook, 4 contexts - ready to use out of the box |
+| **Batteries Included** | 42 agents, 52 skills, 22 guides, 18 rules, 1 hook, 1 context - ready to use out of the box |
 | **Sub-Agent Model** | Supports hierarchical agent orchestration with specialized roles |
 | **Dead Simple Customization** | Create a folder + markdown file = new agent or skill |
 | **Mix and Match** | Use built-in components, create your own, or combine both |
@@ -47,6 +47,11 @@ oh-my-customcode can operate in both Claude-native and Codex-native modes. The C
 4. Project markers (`AGENTS.md`/`.codex` vs `CLAUDE.md`/`.claude`)
 5. Default: `claude`
 
+**Claude Mode** generates `.claude/` directory with `CLAUDE.md` entry point.
+**Codex Mode** generates `.codex/` directory with `AGENTS.md` entry point.
+
+Both modes install the same agents, skills, guides, and rules — only the directory layout and entry file differ.
+
 ## Customization First
 
 This is what oh-my-customcode is all about. **Making Claude Code yours.**
@@ -129,7 +134,7 @@ Claude Code selects the appropriate model and parallelizes independent tasks (up
 | **QA** | 3 | qa-planner, qa-writer, qa-engineer |
 | **Total** | **42** | |
 
-### Skills (51)
+### Skills (52)
 
 Includes slash commands and capabilities:
 
@@ -165,9 +170,9 @@ Comprehensive reference documentation covering:
 
 Event-driven automation for Claude Code lifecycle events (PreToolUse, PostToolUse, etc.).
 
-### Contexts (4)
+### Contexts (1)
 
-Shared context files for cross-agent knowledge and mode configurations.
+Shared context file for cross-agent knowledge and mode configurations.
 
 ---
 
@@ -183,6 +188,13 @@ Shared context files for cross-agent knowledge and mode configurations.
 | `omcustom doctor` | Verify installation health |
 | `omcustom doctor --fix` | Auto-fix common issues |
 
+**Global Options:**
+| Option | Description |
+|--------|-------------|
+| `--skip-version-check` | Skip CLI tool version pre-flight check |
+| `-v, --version` | Show version number |
+| `-h, --help` | Show help |
+
 ---
 
 ## Project Structure
@@ -191,25 +203,21 @@ After `omcustom init`:
 
 ```
 your-project/
-├── CLAUDE.md              # Entry point for Claude
-└── .claude/
+├── CLAUDE.md              # Entry point for Claude (or AGENTS.md for Codex)
+└── .claude/               # (or .codex/)
     ├── rules/             # Behavior rules (18 total)
     ├── hooks/             # Event hooks (1 total)
-    ├── contexts/          # Context files (4 total)
-    ├── agents/            # All agents (flat structure, 42 total)
-    │   ├── lang-golang-expert/
-    │   ├── be-fastapi-expert/
-    │   ├── de-airflow-expert/
-    │   ├── mgr-creator/
+    ├── contexts/          # Context files (1 total)
+    ├── agents/            # Agent definitions (42 flat .md files)
+    │   ├── lang-golang-expert.md
+    │   ├── be-fastapi-expert.md
+    │   ├── mgr-creator.md
+    │   └── ...
+    ├── skills/            # Skill modules (52 directories, each with SKILL.md)
+    │   ├── go-best-practices/
+    │   ├── react-best-practices/
+    │   ├── secretary-routing/
     │   └── ...
-    ├── skills/            # All skills (51 total, includes slash commands)
-    │   ├── development/
-    │   ├── backend/
-    │   ├── data-engineering/
-    │   ├── database/
-    │   ├── infrastructure/
-    │   ├── system/
-    │   └── orchestration/
     └── guides/            # Reference docs (22 total)
 ```
 
@@ -227,7 +235,7 @@ bun run build        # Build for production
 ### Requirements
 
 - Node.js >= 18.0.0
-- Claude Code CLI
+- Claude Code CLI or OpenAI Codex CLI
 
 ---
 

package/dist/cli/index.js

@@ -9033,6 +9033,214 @@ var {
   Help
 } = import__.default;
 
+// src/core/preflight.ts
+import { execSync } from "node:child_process";
+function isCI() {
+  const ciEnvVars = ["CI", "GITHUB_ACTIONS", "OMCUSTOM_SKIP_PREFLIGHT"];
+  return ciEnvVars.some((envVar) => process.env[envVar] === "true");
+}
+function hasHomebrew() {
+  try {
+    execSync("which brew", { encoding: "utf-8", stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getToolInfoFromBrew(toolName) {
+  const tool = {
+    name: toolName,
+    installed: false,
+    currentVersion: null,
+    latestVersion: null,
+    updateAvailable: false,
+    installMethod: "homebrew"
+  };
+  try {
+    const infoOutput = execSync(`brew info --json=v2 ${toolName}`, {
+      encoding: "utf-8",
+      stdio: "pipe",
+      timeout: 3000
+    });
+    const info = JSON.parse(infoOutput);
+    if (info.casks && info.casks.length > 0) {
+      const cask = info.casks[0];
+      tool.latestVersion = cask.version;
+      tool.currentVersion = cask.installed || null;
+      tool.installed = cask.installed !== null;
+    }
+    if (!tool.installed && info.formulae && info.formulae.length > 0) {
+      const formula = info.formulae[0];
+      tool.latestVersion = formula.versions.stable;
+      if (formula.installed && formula.installed.length > 0) {
+        tool.currentVersion = formula.installed[0].version;
+        tool.installed = true;
+      }
+    }
+    if (tool.installed && tool.currentVersion && tool.latestVersion) {
+      tool.updateAvailable = tool.currentVersion !== tool.latestVersion;
+    }
+  } catch {}
+  return tool;
+}
+function getToolInfoFromNpm(toolName) {
+  const tool = {
+    name: toolName,
+    installed: false,
+    currentVersion: null,
+    latestVersion: null,
+    updateAvailable: false,
+    installMethod: "npm"
+  };
+  try {
+    const versionOutput = execSync(`npx ${toolName} --version`, {
+      encoding: "utf-8",
+      stdio: "pipe",
+      timeout: 3000
+    });
+    const version = versionOutput.trim();
+    if (version) {
+      tool.installed = true;
+      tool.currentVersion = version;
+    }
+  } catch {}
+  return tool;
+}
+function getToolInfo(toolName) {
+  if (hasHomebrew()) {
+    const brewTool = getToolInfoFromBrew(toolName);
+    if (brewTool.installed) {
+      return brewTool;
+    }
+  }
+  const npmTool = getToolInfoFromNpm(toolName);
+  if (npmTool.installed) {
+    return npmTool;
+  }
+  return {
+    name: toolName,
+    installed: false,
+    currentVersion: null,
+    latestVersion: null,
+    updateAvailable: false,
+    installMethod: "unknown"
+  };
+}
+function checkOutdated(tools) {
+  if (!hasHomebrew())
+    return;
+  try {
+    const toolNames = tools.map((t) => t.name).join(" ");
+    const outdatedOutput = execSync(`brew outdated --json=v2 ${toolNames}`, {
+      encoding: "utf-8",
+      stdio: "pipe",
+      timeout: 3000
+    });
+    const outdated = JSON.parse(outdatedOutput);
+    const outdatedCasks = outdated.casks || [];
+    const outdatedFormulae = outdated.formulae || [];
+    for (const tool of tools) {
+      const outdatedCask = outdatedCasks.find((c) => c.name === tool.name);
+      const outdatedFormula = outdatedFormulae.find((f) => f.name === tool.name);
+      if (outdatedCask) {
+        tool.latestVersion = outdatedCask.current_version;
+        tool.updateAvailable = true;
+      } else if (outdatedFormula) {
+        tool.latestVersion = outdatedFormula.current_version;
+        tool.updateAvailable = true;
+      }
+    }
+  } catch {}
+}
+async function runPreflightCheck(options = {}) {
+  const { skip = false, tools: toolNames = ["claude-code", "codex"], timeout = 5000 } = options;
+  if (skip) {
+    return {
+      tools: [],
+      hasUpdates: false,
+      warnings: [],
+      skipped: true,
+      skipReason: "Skipped by --skip-version-check flag"
+    };
+  }
+  if (isCI()) {
+    return {
+      tools: [],
+      hasUpdates: false,
+      warnings: [],
+      skipped: true,
+      skipReason: "CI environment detected"
+    };
+  }
+  if (!hasHomebrew()) {
+    return {
+      tools: [],
+      hasUpdates: false,
+      warnings: ["Homebrew not found, skipping version check"],
+      skipped: true,
+      skipReason: "Homebrew not available"
+    };
+  }
+  return new Promise((resolve) => {
+    const timeoutId = setTimeout(() => {
+      resolve({
+        tools: [],
+        hasUpdates: false,
+        warnings: ["Version check timed out"],
+        skipped: true,
+        skipReason: "Timeout"
+      });
+    }, timeout);
+    try {
+      const tools = [];
+      for (const toolName of toolNames) {
+        const tool = getToolInfo(toolName);
+        tools.push(tool);
+      }
+      checkOutdated(tools);
+      const hasUpdates = tools.some((t) => t.updateAvailable);
+      const warnings = [];
+      clearTimeout(timeoutId);
+      resolve({
+        tools,
+        hasUpdates,
+        warnings,
+        skipped: false
+      });
+    } catch (error) {
+      clearTimeout(timeoutId);
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      resolve({
+        tools: [],
+        hasUpdates: false,
+        warnings: [`Pre-flight check failed: ${errorMessage}`],
+        skipped: true,
+        skipReason: "Error during check"
+      });
+    }
+  });
+}
+function formatPreflightWarnings(result) {
+  if (!result.hasUpdates) {
+    return "";
+  }
+  const lines = [];
+  const updatesAvailable = result.tools.filter((t) => t.updateAvailable);
+  if (updatesAvailable.length === 1) {
+    const tool = updatesAvailable[0];
+    lines.push(`⚠ ${tool.name} ${tool.latestVersion} is available (current: ${tool.currentVersion})`);
+    lines.push(`  Run: brew upgrade ${tool.name}`);
+  } else if (updatesAvailable.length > 1) {
+    lines.push("Run the following to upgrade:");
+    for (const tool of updatesAvailable) {
+      lines.push(`  brew upgrade ${tool.name}  # ${tool.latestVersion} available (current: ${tool.currentVersion})`);
+    }
+  }
+  lines.push("  Use --skip-version-check to skip this check");
+  return lines.join(`
+`);
+}
+
 // node_modules/i18next/dist/esm/i18next.js
 var isString = (obj) => typeof obj === "string";
 var defer = () => {
@@ -11461,6 +11669,17 @@ var en_default = {
     error: {
       unexpected: "An unexpected error occurred:"
     },
+    preflight: {
+      checking: "Checking CLI tool versions...",
+      updateAvailable: "⚠ {{name}} {{latest}} is available (current: {{current}})",
+      upgradeCommand: "  Run: brew upgrade {{name}}",
+      multipleUpdates: "Run the following to upgrade:",
+      skipFlag: "  Use --skip-version-check to skip this check",
+      skippedCi: "Skipping version check (CI environment detected)",
+      skippedFlag: "Skipping version check (--skip-version-check)",
+      homebrewNotFound: "Homebrew not found, skipping version check",
+      timeout: "Version check timed out, continuing..."
+    },
     init: {
       description: "Initialize oh-my-customcode in the current directory",
       langOption: "Language for templates (en or ko)",
@@ -11503,7 +11722,25 @@ var en_default = {
       latestVersion: "Latest version: {{version}}",
       changelog: "Changelog",
       promptUpdate: "Do you want to update?",
-      skipped: "Update skipped"
+      skipped: "Update skipped",
+      dryRunOption: "Show what would be updated without making changes",
+      forceOption: "Force update even if already at latest version",
+      backupOption: "Create backup before updating",
+      agentsOption: "Update only agents",
+      skillsOption: "Update only skills",
+      rulesOption: "Update only rules",
+      guidesOption: "Update only guides",
+      hooksOption: "Update only hooks",
+      contextsOption: "Update only contexts",
+      providerOption: "Provider to update (auto, claude, codex)",
+      dryRunHeader: "Dry run - no changes will be made:",
+      componentUpdated: "✓ {{component}} updated",
+      componentSkipped: "- {{component}} skipped (no changes)",
+      componentFailed: "✗ {{component}} failed: {{error}}",
+      preservedFiles: "Preserved {{count}} user-customized files",
+      backupCreated: "Backup created at {{path}}",
+      summary: "Update complete: {{updated}} updated, {{skipped}} skipped",
+      summaryFailed: "Update failed: {{error}}"
     },
     list: {
       description: "List installed components",
@@ -11715,6 +11952,17 @@ var ko_default = {
     error: {
       unexpected: "예기치 않은 오류가 발생했습니다:"
     },
+    preflight: {
+      checking: "CLI 도구 버전 확인 중...",
+      updateAvailable: "⚠ {{name}} {{latest}} 사용 가능 (현재: {{current}})",
+      upgradeCommand: "  실행: brew upgrade {{name}}",
+      multipleUpdates: "다음을 실행하여 업그레이드하세요:",
+      skipFlag: "  --skip-version-check 옵션으로 이 검사를 건너뛸 수 있습니다",
+      skippedCi: "버전 확인 건너뜀 (CI 환경 감지)",
+      skippedFlag: "버전 확인 건너뜀 (--skip-version-check)",
+      homebrewNotFound: "Homebrew를 찾을 수 없어 버전 확인을 건너뜁니다",
+      timeout: "버전 확인 시간 초과, 계속 진행합니다..."
+    },
     init: {
       description: "현재 디렉토리에 oh-my-customcode 초기화",
       langOption: "템플릿 언어 (en 또는 ko)",
@@ -11757,7 +12005,25 @@ var ko_default = {
       latestVersion: "최신 버전: {{version}}",
       changelog: "변경 내역",
       promptUpdate: "업데이트하시겠습니까?",
-      skipped: "업데이트 건너뜀"
+      skipped: "업데이트 건너뜀",
+      dryRunOption: "변경 없이 업데이트할 내용 표시",
+      forceOption: "이미 최신 버전이어도 강제 업데이트",
+      backupOption: "업데이트 전 백업 생성",
+      agentsOption: "에이전트만 업데이트",
+      skillsOption: "스킬만 업데이트",
+      rulesOption: "규칙만 업데이트",
+      guidesOption: "가이드만 업데이트",
+      hooksOption: "훅만 업데이트",
+      contextsOption: "컨텍스트만 업데이트",
+      providerOption: "업데이트할 제공자 (auto, claude, codex)",
+      dryRunHeader: "드라이 런 - 변경사항 없음:",
+      componentUpdated: "✓ {{component}} 업데이트됨",
+      componentSkipped: "- {{component}} 건너뜀 (변경사항 없음)",
+      componentFailed: "✗ {{component}} 실패: {{error}}",
+      preservedFiles: "사용자 커스터마이징 파일 {{count}}개 보존됨",
+      backupCreated: "백업 생성됨: {{path}}",
+      summary: "업데이트 완료: {{updated}}개 업데이트, {{skipped}}개 건너뜀",
+      summaryFailed: "업데이트 실패: {{error}}"
     },
     list: {
       description: "설치된 컴포넌트 목록 표시",
@@ -13795,73 +14061,279 @@ async function listCommand(type = "all", options = {}) {
   }
 }
 
-// src/cli/update.ts
-async function getCurrentVersion() {
-  return null;
+// src/core/updater.ts
+import { join as join7 } from "node:path";
+var CUSTOMIZATION_MANIFEST_FILE = ".omcustom-customizations.json";
+function createUpdateResult() {
+  return {
+    success: false,
+    updatedComponents: [],
+    skippedComponents: [],
+    preservedFiles: [],
+    backedUpPaths: [],
+    previousVersion: "",
+    newVersion: "",
+    warnings: []
+  };
+}
+async function handleBackupIfRequested(targetDir, provider, backup, result) {
+  if (!backup)
+    return;
+  const backupPath = await backupInstallation(targetDir, provider);
+  result.backedUpPaths.push(backupPath);
+  info("update.backup_created", { path: backupPath });
+}
+async function processComponentUpdate(targetDir, provider, 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, provider, 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, provider, components, updateCheck, customizations, options, result) {
+  for (const component of components) {
+    await processComponentUpdate(targetDir, provider, component, updateCheck, customizations, options, result);
+  }
 }
-async function getLatestVersion() {
+async function update(options) {
+  const result = createUpdateResult();
+  try {
+    info("update.start", { targetDir: options.targetDir });
+    const config = await loadConfig(options.targetDir);
+    const provider = options.provider ?? (config.provider === "codex" ? "codex" : "claude");
+    result.previousVersion = config.version;
+    const updateCheck = await checkForUpdates(options.targetDir, provider);
+    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, provider, !!options.backup, result);
+    const customizations = options.preserveCustomizations !== false ? await loadCustomizationManifest(options.targetDir) : null;
+    const components = options.components || getAllUpdateComponents();
+    await updateAllComponents(options.targetDir, provider, 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, provider = "claude") {
+  const config = await loadConfig(targetDir);
+  const currentVersion = config.version;
+  const latestVersion = await getLatestVersion(provider);
+  const updatableComponents = [];
+  for (const component of getAllUpdateComponents()) {
+    const hasUpdate = await componentHasUpdate(targetDir, provider, component, config);
+    if (hasUpdate) {
+      updatableComponents.push({
+        name: component,
+        currentVersion: config.componentVersions?.[component] || "0.0.0",
+        latestVersion
+      });
+    }
+  }
   return {
-    version: "0.0.0",
-    lastUpdated: new Date().toISOString(),
-    source: "https://github.com/baekenough/oh-my-customcode"
+    hasUpdates: updatableComponents.length > 0 || currentVersion !== latestVersion,
+    currentVersion,
+    latestVersion,
+    updatableComponents,
+    checkedAt: new Date().toISOString()
   };
 }
-async function checkUpdateAvailable() {
-  const current = await getCurrentVersion();
-  const latest = await getLatestVersion();
-  if (!current) {
+async function preserveCustomizations(targetDir, customizations) {
+  const preserved = new Map;
+  const fs2 = await import("node:fs/promises");
+  for (const filePath of customizations) {
+    const fullPath = join7(targetDir, filePath);
+    if (await fileExists(fullPath)) {
+      const content = await fs2.readFile(fullPath, "utf-8");
+      preserved.set(filePath, content);
+    }
+  }
+  return preserved;
+}
+function getAllUpdateComponents() {
+  return ["rules", "agents", "skills", "guides", "hooks", "contexts"];
+}
+async function getLatestVersion(provider) {
+  const layout = getProviderLayout(provider);
+  const manifestPath = resolveTemplatePath(layout.manifestFile);
+  if (await fileExists(manifestPath)) {
+    const manifest = await readJsonFile(manifestPath);
+    return manifest.version;
+  }
+  return "0.0.0";
+}
+async function componentHasUpdate(_targetDir, provider, component, config) {
+  const installedVersion = config.componentVersions?.[component];
+  if (!installedVersion) {
     return true;
   }
-  return current.version !== latest.version;
+  const latestVersion = await getLatestVersion(provider);
+  return installedVersion !== latestVersion;
+}
+async function updateComponent(targetDir, provider, component, customizations, options) {
+  const preservedFiles = [];
+  const componentPath = getComponentPath2(provider, component);
+  const srcPath = resolveTemplatePath(componentPath);
+  const destPath = join7(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 fs2 = await import("node:fs/promises");
+      for (const [path2, content] of preserved) {
+        await fs2.writeFile(join7(targetDir, path2), 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 getComponentPath2(provider, component) {
+  const layout = getProviderLayout(provider);
+  if (component === "guides") {
+    return "guides";
+  }
+  return `${layout.rootDir}/${component}`;
 }
-async function applyUpdates(_options) {
-  const updatedComponents = [];
-  return updatedComponents;
+async function backupInstallation(targetDir, provider) {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const backupDir = join7(targetDir, `.omcustom-backup-${timestamp}`);
+  const fs2 = await import("node:fs/promises");
+  await ensureDirectory(backupDir);
+  const layout = getProviderLayout(provider);
+  const dirsToBackup = [layout.rootDir, "guides"];
+  for (const dir2 of dirsToBackup) {
+    const srcPath = join7(targetDir, dir2);
+    if (await fileExists(srcPath)) {
+      const destPath = join7(backupDir, dir2);
+      await copyDirectory(srcPath, destPath, { overwrite: true });
+    }
+  }
+  const entryPath = join7(targetDir, layout.entryFile);
+  if (await fileExists(entryPath)) {
+    await fs2.copyFile(entryPath, join7(backupDir, layout.entryFile));
+  }
+  return backupDir;
 }
+async function loadCustomizationManifest(targetDir) {
+  const manifestPath = join7(targetDir, CUSTOMIZATION_MANIFEST_FILE);
+  if (await fileExists(manifestPath)) {
+    return readJsonFile(manifestPath);
+  }
+  return null;
+}
+
+// src/cli/update.ts
 async function updateCommand(options = {}) {
-  console.log(i18n.t("cli.update.checking"));
   try {
-    const currentVersion = await getCurrentVersion();
-    const latestVersion = await getLatestVersion();
-    if (!currentVersion) {
-      console.log(i18n.t("cli.update.notInstalled"));
-      return {
-        success: false,
-        message: i18n.t("cli.update.notInstalled"),
-        errors: [i18n.t("cli.update.runInitFirst")]
-      };
-    }
-    const updateAvailable = await checkUpdateAvailable();
-    if (!updateAvailable && !options.force) {
-      console.log(i18n.t("cli.update.alreadyLatest"));
-      return {
-        success: true,
-        message: i18n.t("cli.update.alreadyLatest"),
-        currentVersion: currentVersion.version,
-        newVersion: latestVersion.version
-      };
+    const targetDir = process.cwd();
+    const detection = await detectProvider({
+      targetDir,
+      override: options.provider
+    });
+    const provider = detection.provider;
+    const components = buildComponentsList(options);
+    if (options.dryRun) {
+      console.log(i18n.t("cli.update.dryRunHeader"));
     }
-    console.log(i18n.t("cli.update.updating", {
-      from: currentVersion.version,
-      to: latestVersion.version
-    }));
-    const updatedComponents = await applyUpdates(options);
-    console.log(i18n.t("cli.update.success"));
-    return {
-      success: true,
-      message: i18n.t("cli.update.success"),
-      updatedComponents,
-      currentVersion: currentVersion.version,
-      newVersion: latestVersion.version
+    const updateOptions = {
+      targetDir,
+      provider,
+      components,
+      force: options.force,
+      preserveCustomizations: true,
+      dryRun: options.dryRun,
+      backup: options.backup
     };
+    const result = await update(updateOptions);
+    printUpdateResults(result);
+    if (!result.success) {
+      process.exit(1);
+    }
   } catch (error2) {
     const errorMessage = error2 instanceof Error ? error2.message : String(error2);
-    console.error(i18n.t("cli.update.failed"), errorMessage);
-    return {
-      success: false,
-      message: i18n.t("cli.update.failed"),
-      errors: [errorMessage]
-    };
+    console.error(i18n.t("cli.update.summaryFailed", { error: errorMessage }));
+    process.exit(1);
+  }
+}
+function buildComponentsList(options) {
+  const components = [];
+  if (options.agents) {
+    components.push("agents");
+  }
+  if (options.skills) {
+    components.push("skills");
+  }
+  if (options.rules) {
+    components.push("rules");
+  }
+  if (options.guides) {
+    components.push("guides");
+  }
+  if (options.hooks) {
+    components.push("hooks");
+  }
+  if (options.contexts) {
+    components.push("contexts");
+  }
+  return components.length > 0 ? components : undefined;
+}
+function printUpdateResults(result) {
+  for (const component of result.updatedComponents) {
+    console.log(i18n.t("cli.update.componentUpdated", { component }));
+  }
+  for (const component of result.skippedComponents) {
+    console.log(i18n.t("cli.update.componentSkipped", { component }));
+  }
+  if (result.preservedFiles.length > 0) {
+    console.log(i18n.t("cli.update.preservedFiles", { count: result.preservedFiles.length }));
+  }
+  if (result.backedUpPaths.length > 0) {
+    for (const path2 of result.backedUpPaths) {
+      console.log(i18n.t("cli.update.backupCreated", { path: path2 }));
+    }
+  }
+  for (const warning of result.warnings) {
+    console.warn(warning);
+  }
+  if (result.success) {
+    console.log(i18n.t("cli.update.summary", {
+      updated: result.updatedComponents.length,
+      skipped: result.skippedComponents.length
+    }));
+  } else if (result.error) {
+    console.error(i18n.t("cli.update.summaryFailed", { error: result.error }));
   }
 }
 
@@ -13870,12 +14342,12 @@ var require2 = createRequire2(import.meta.url);
 var packageJson = require2("../../package.json");
 function createProgram() {
   const program2 = new Command;
-  program2.name("omcustom").description(i18n.t("cli.description")).version(packageJson.version, "-v, --version", i18n.t("cli.versionOption"));
+  program2.name("omcustom").description(i18n.t("cli.description")).version(packageJson.version, "-v, --version", i18n.t("cli.versionOption")).option("--skip-version-check", "Skip CLI version pre-flight check");
   program2.command("init").description(i18n.t("cli.init.description")).option("-l, --lang <language>", i18n.t("cli.init.langOption"), "en").option("-p, --provider <provider>", i18n.t("cli.init.providerOption"), "auto").action(async (options) => {
     await initCommand(options);
   });
-  program2.command("update").description(i18n.t("cli.update.description")).action(async () => {
-    await updateCommand();
+  program2.command("update").description(i18n.t("cli.update.description")).option("--dry-run", i18n.t("cli.update.dryRunOption")).option("--force", i18n.t("cli.update.forceOption")).option("--backup", i18n.t("cli.update.backupOption")).option("--agents", i18n.t("cli.update.agentsOption")).option("--skills", i18n.t("cli.update.skillsOption")).option("--rules", i18n.t("cli.update.rulesOption")).option("--guides", i18n.t("cli.update.guidesOption")).option("--hooks", i18n.t("cli.update.hooksOption")).option("--contexts", i18n.t("cli.update.contextsOption")).option("-p, --provider <provider>", i18n.t("cli.update.providerOption"), "auto").action(async (options) => {
+    await updateCommand(options);
   });
   program2.command("list").description(i18n.t("cli.list.description")).argument("[type]", i18n.t("cli.list.typeArgument"), "all").option("-f, --format <format>", "Output format: table, json, or simple", "table").option("--verbose", "Show detailed information").option("-p, --provider <provider>", i18n.t("cli.list.providerOption"), "auto").action(async (type, options) => {
     await listCommand(type, {
@@ -13887,6 +14359,16 @@ function createProgram() {
   program2.command("doctor").description(i18n.t("cli.doctor.description")).option("--fix", i18n.t("cli.doctor.fixOption")).option("-p, --provider <provider>", i18n.t("cli.doctor.providerOption"), "auto").action(async (options) => {
     await doctorCommand(options);
   });
+  program2.hook("preAction", async (thisCommand) => {
+    const opts = thisCommand.optsWithGlobals();
+    const skipCheck = opts.skipVersionCheck || false;
+    const result = await runPreflightCheck({ skip: skipCheck });
+    if (result.hasUpdates) {
+      const warnings = formatPreflightWarnings(result);
+      console.warn(warnings);
+      console.warn("");
+    }
+  });
   return program2;
 }
 async function main() {

package/dist/index.js

@@ -1,20 +1,4 @@
 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/config.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-customcode",
-  "version": "0.9.1",
+  "version": "0.9.3",
   "description": "Batteries-included agent harness for Claude Code",
   "type": "module",
   "bin": {

package/templates/.codex/codex-native-hash.txt

@@ -1 +0,0 @@
-4e8d4e056e9633819fc41f927e1c18a6bc757636abbac85552a767664df242f4