oh-my-customcode 0.12.0 → 0.12.1

package/dist/cli/index.js

@@ -9241,6 +9241,13 @@ function formatPreflightWarnings(result) {
 `);
 }
 
+// src/core/self-update.ts
+import { execSync as execSync2, spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { createInterface } from "node:readline/promises";
+
 // node_modules/i18next/dist/esm/i18next.js
 var isString = (obj) => typeof obj === "string";
 var defer = () => {
@@ -11656,7 +11663,7 @@ var en_default = {
     unknownError: "An unknown error occurred"
   },
   cli: {
-    description: "Batteries-included agent harness for Claude Code",
+    description: "Batteries-included agent harness for Claude Code and OpenAI Codex",
     versionOption: "Show version number",
     usage: "Usage: omcustom <command> [options]",
     commands: "Commands",
@@ -11680,6 +11687,18 @@ var en_default = {
       homebrewNotFound: "Homebrew not found, skipping version check",
       timeout: "Version check timed out, continuing..."
     },
+    selfUpdate: {
+      checking: "Checking for oh-my-customcode updates...",
+      available: "📦 New version available: v{{current}} → v{{latest}}",
+      prompt: "Would you like to update oh-my-customcode first? (Y/n): ",
+      updatingGlobal: "⬆️ Updating oh-my-customcode globally to v{{version}}...",
+      updatingNpx: "⬆️ Launching latest version via npx (v{{version}})...",
+      updated: "✅ Updated to v{{version}}",
+      declined: "Continuing with current version.",
+      failed: "Self-update failed: {{error}}",
+      relaunchFailed: "Failed to launch latest version via npx (status: {{status}}).",
+      continueAfterFailure: "Continuing init with current version."
+    },
     init: {
       description: "Initialize oh-my-customcode in the current directory",
       langOption: "Language for templates (en or ko)",
@@ -11940,7 +11959,7 @@ var ko_default = {
     unknownError: "알 수 없는 오류가 발생했습니다"
   },
   cli: {
-    description: "Claude Code를 위한 올인원 에이전트 하네스",
+    description: "Claude Code와 OpenAI Codex를 위한 올인원 에이전트 하네스",
     versionOption: "버전 번호 표시",
     usage: "사용법: omcustom <명령어> [옵션]",
     commands: "명령어",
@@ -11964,6 +11983,18 @@ var ko_default = {
       homebrewNotFound: "Homebrew를 찾을 수 없어 버전 확인을 건너뜁니다",
       timeout: "버전 확인 시간 초과, 계속 진행합니다..."
     },
+    selfUpdate: {
+      checking: "oh-my-customcode 업데이트 확인 중...",
+      available: "📦 새 버전 사용 가능: v{{current}} → v{{latest}}",
+      prompt: "먼저 oh-my-customcode를 업데이트할까요? (Y/n): ",
+      updatingGlobal: "⬆️ oh-my-customcode를 전역으로 v{{version}}로 업데이트 중...",
+      updatingNpx: "⬆️ npx로 최신 버전(v{{version}})을 실행합니다...",
+      updated: "✅ v{{version}}로 업데이트되었습니다",
+      declined: "현재 버전으로 계속 진행합니다.",
+      failed: "자체 업데이트 실패: {{error}}",
+      relaunchFailed: "npx 최신 버전 실행 실패 (status: {{status}}).",
+      continueAfterFailure: "현재 버전으로 init을 계속 진행합니다."
+    },
     init: {
       description: "현재 디렉토리에 oh-my-customcode 초기화",
       langOption: "템플릿 언어 (en 또는 ko)",
@@ -12247,6 +12278,242 @@ var i18n = {
   }
 };
 
+// src/core/self-update.ts
+var DEFAULT_PACKAGE_NAME = "oh-my-customcode";
+var DEFAULT_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+var DEFAULT_CACHE_PATH = join(homedir(), ".oh-my-customcode", "self-update-cache.json");
+function normalizeVersion(version) {
+  return version.trim().replace(/^v/i, "").split("-")[0] || "";
+}
+function compareSemver(a, b) {
+  const left = normalizeVersion(a).split(".").map((n) => Number.parseInt(n, 10) || 0);
+  const right = normalizeVersion(b).split(".").map((n) => Number.parseInt(n, 10) || 0);
+  const maxLen = Math.max(left.length, right.length, 3);
+  for (let i = 0;i < maxLen; i += 1) {
+    const l = left[i] ?? 0;
+    const r = right[i] ?? 0;
+    if (l < r)
+      return -1;
+    if (l > r)
+      return 1;
+  }
+  return 0;
+}
+function isInteractiveSession(stdin = process.stdin, stdout = process.stdout) {
+  return Boolean(stdin.isTTY && stdout.isTTY);
+}
+function isNpxInvocation(argv = process.argv, env = process.env) {
+  const argv1 = argv[1] || "";
+  const npmExecPath = env.npm_execpath || "";
+  const npmCommand = env.npm_command || "";
+  return argv1.includes("/_npx/") || argv1.includes("\\_npx\\") || npmExecPath.includes("npx") || npmCommand === "exec" || env.npm_lifecycle_event === "npx";
+}
+function readCache(cachePath) {
+  if (!existsSync(cachePath)) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(readFileSync(cachePath, "utf-8"));
+    if (!parsed.checkedAt || !parsed.latestVersion) {
+      return null;
+    }
+    return {
+      checkedAt: parsed.checkedAt,
+      latestVersion: parsed.latestVersion
+    };
+  } catch {
+    return null;
+  }
+}
+function writeCache(cachePath, latestVersion, now) {
+  const dir2 = dirname(cachePath);
+  if (!existsSync(dir2)) {
+    mkdirSync(dir2, { recursive: true });
+  }
+  const payload = {
+    checkedAt: new Date(now).toISOString(),
+    latestVersion
+  };
+  writeFileSync(cachePath, `${JSON.stringify(payload, null, 2)}
+`, "utf-8");
+}
+function isCacheFresh(cache, now, cacheTtlMs) {
+  const checkedAt = new Date(cache.checkedAt).getTime();
+  if (Number.isNaN(checkedAt)) {
+    return false;
+  }
+  return now - checkedAt < cacheTtlMs;
+}
+function fetchLatestVersionFromNpm(packageName = DEFAULT_PACKAGE_NAME) {
+  try {
+    const output = execSync2(`npm view ${packageName} version --json`, {
+      encoding: "utf-8",
+      stdio: "pipe",
+      timeout: 3000
+    }).trim();
+    if (!output) {
+      return null;
+    }
+    let version;
+    if (output.startsWith('"')) {
+      version = JSON.parse(output);
+    } else {
+      version = output;
+    }
+    const normalized = normalizeVersion(version);
+    return normalized || null;
+  } catch {
+    return null;
+  }
+}
+function printContinuationSpacing() {
+  console.log("");
+}
+function printContinueCurrentVersion() {
+  console.warn(i18n.t("cli.selfUpdate.continueAfterFailure"));
+  printContinuationSpacing();
+}
+function runNpxRelaunch(packageName, latestVersion, argv, env) {
+  console.log(i18n.t("cli.selfUpdate.updatingNpx", { version: latestVersion }));
+  const forwardedArgs = argv.slice(2);
+  const child = spawnSync("npx", ["-y", `${packageName}@${latestVersion}`, ...forwardedArgs], {
+    stdio: "inherit",
+    env: {
+      ...env,
+      OMCUSTOM_SKIP_SELF_UPDATE: "true"
+    }
+  });
+  if ((child.status ?? 1) === 0) {
+    process.exit(0);
+  }
+  const status = child.status ?? -1;
+  console.warn(i18n.t("cli.selfUpdate.relaunchFailed", { status }));
+  printContinueCurrentVersion();
+}
+function runGlobalUpdate(packageName, latestVersion) {
+  try {
+    console.log(i18n.t("cli.selfUpdate.updatingGlobal", { version: latestVersion }));
+    execSync2(`npm install -g ${packageName}@${latestVersion}`, {
+      stdio: "inherit",
+      timeout: 60000
+    });
+    console.log(i18n.t("cli.selfUpdate.updated", { version: latestVersion }));
+    printContinuationSpacing();
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.warn(i18n.t("cli.selfUpdate.failed", { error: errorMessage }));
+    printContinueCurrentVersion();
+  }
+}
+function checkSelfUpdate(options) {
+  const packageName = options.packageName || DEFAULT_PACKAGE_NAME;
+  const cachePath = options.cachePath || DEFAULT_CACHE_PATH;
+  const cacheTtlMs = options.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS;
+  const fetchLatestVersion = options.fetchLatestVersion || fetchLatestVersionFromNpm;
+  const now = options.now ?? Date.now();
+  const currentVersion = normalizeVersion(options.currentVersion);
+  if (!currentVersion) {
+    return {
+      checked: false,
+      updateAvailable: false,
+      latestVersion: null,
+      usedCache: false,
+      reason: "invalid-current-version"
+    };
+  }
+  let latestVersion = null;
+  let usedCache = false;
+  const cache = readCache(cachePath);
+  if (cache && isCacheFresh(cache, now, cacheTtlMs)) {
+    latestVersion = normalizeVersion(cache.latestVersion);
+    usedCache = true;
+  }
+  if (!latestVersion) {
+    latestVersion = fetchLatestVersion(packageName);
+    if (latestVersion) {
+      writeCache(cachePath, latestVersion, now);
+    }
+  }
+  if (!latestVersion) {
+    return {
+      checked: false,
+      updateAvailable: false,
+      latestVersion: null,
+      usedCache,
+      reason: "lookup-failed"
+    };
+  }
+  return {
+    checked: true,
+    updateAvailable: compareSemver(currentVersion, latestVersion) < 0,
+    latestVersion,
+    usedCache
+  };
+}
+async function promptForSelfUpdate() {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    const answer = await rl.question(i18n.t("cli.selfUpdate.prompt"));
+    const normalized = answer.trim().toLowerCase();
+    return normalized === "" || normalized === "y" || normalized === "yes";
+  } finally {
+    rl.close();
+  }
+}
+function shouldSkipSelfUpdate(options) {
+  const env = options.env || process.env;
+  const argv = options.argv || process.argv;
+  if (options.skip) {
+    return true;
+  }
+  if (argv.includes("--skip-version-check")) {
+    return true;
+  }
+  if (env.OMCUSTOM_SKIP_SELF_UPDATE === "true") {
+    return true;
+  }
+  if (env.CI === "true" || env.GITHUB_ACTIONS === "true") {
+    return true;
+  }
+  if (!isInteractiveSession()) {
+    return true;
+  }
+  return false;
+}
+async function maybeHandleSelfUpdateForInit(options) {
+  if (shouldSkipSelfUpdate(options)) {
+    return;
+  }
+  const packageName = options.packageName || DEFAULT_PACKAGE_NAME;
+  const currentVersion = normalizeVersion(options.currentVersion);
+  const argv = options.argv || process.argv;
+  const env = options.env || process.env;
+  if (!currentVersion) {
+    return;
+  }
+  console.log(i18n.t("cli.selfUpdate.checking"));
+  const result = checkSelfUpdate(options);
+  if (!result.checked || !result.updateAvailable || !result.latestVersion) {
+    return;
+  }
+  const latestVersion = result.latestVersion;
+  console.log(i18n.t("cli.selfUpdate.available", { current: currentVersion, latest: latestVersion }));
+  const wantsUpdate = await promptForSelfUpdate();
+  if (!wantsUpdate) {
+    console.log(i18n.t("cli.selfUpdate.declined"));
+    printContinuationSpacing();
+    return;
+  }
+  if (isNpxInvocation(argv, env)) {
+    runNpxRelaunch(packageName, latestVersion, argv, env);
+    return;
+  }
+  runGlobalUpdate(packageName, latestVersion);
+}
+
 // src/cli/doctor.ts
 import { constants, promises as fs } from "node:fs";
 import path from "node:path";
@@ -12298,10 +12565,10 @@ var $visit = visit.visit;
 var $visitAsync = visit.visitAsync;
 
 // src/core/config.ts
-import { join as join2 } from "node:path";
+import { join as join3 } from "node:path";
 
 // src/utils/fs.ts
-import { dirname, isAbsolute, join, normalize, relative, resolve, sep } from "node:path";
+import { dirname as dirname2, isAbsolute, join as join2, normalize, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 function validatePreserveFilePath(filePath, projectRoot) {
   if (!filePath || filePath.trim() === "") {
@@ -12454,17 +12721,17 @@ async function readTextFile(path) {
 }
 async function writeTextFile(path, content) {
   const fs = await import("node:fs/promises");
-  await ensureDirectory(dirname(path));
+  await ensureDirectory(dirname2(path));
   await fs.writeFile(path, content, "utf-8");
 }
 function getPackageRoot() {
   const currentFile = fileURLToPath(import.meta.url);
-  const currentDir = dirname(currentFile);
+  const currentDir = dirname2(currentFile);
   return resolve(currentDir, "..", "..");
 }
 function resolveTemplatePath(relativePath) {
   const packageRoot = getPackageRoot();
-  return join(packageRoot, "templates", relativePath);
+  return join2(packageRoot, "templates", relativePath);
 }
 async function listFiles(dir2, options = {}) {
   const fs = await import("node:fs/promises");
@@ -12716,7 +12983,7 @@ function getDefaultPreferences() {
   };
 }
 function getConfigPath(targetDir) {
-  return join2(targetDir, CONFIG_FILE);
+  return join3(targetDir, CONFIG_FILE);
 }
 async function loadConfig(targetDir) {
   const configPath = getConfigPath(targetDir);
@@ -12870,7 +13137,7 @@ function getDefaultProvider() {
 }
 
 // src/core/provider.ts
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 var ENV_SIGNALS = {
   claude: [
     "ANTHROPIC_API_KEY",
@@ -12926,8 +13193,8 @@ function detectFromEnv(env) {
   return null;
 }
 async function detectFromProject(targetDir) {
-  const claudeMarkers = [join3(targetDir, "CLAUDE.md"), join3(targetDir, ".claude")];
-  const codexMarkers = [join3(targetDir, "AGENTS.md"), join3(targetDir, ".codex")];
+  const claudeMarkers = [join4(targetDir, "CLAUDE.md"), join4(targetDir, ".claude")];
+  const codexMarkers = [join4(targetDir, "AGENTS.md"), join4(targetDir, ".codex")];
   const claudeFound = await Promise.all(claudeMarkers.map((path) => fileExists(path)));
   const codexFound = await Promise.all(codexMarkers.map((path) => fileExists(path)));
   const hasClaude = claudeFound.some(Boolean);
@@ -12951,7 +13218,7 @@ async function detectFromProject(targetDir) {
   return null;
 }
 async function detectFromConfig(targetDir) {
-  const configPath = join3(targetDir, ".omcustomrc.json");
+  const configPath = join4(targetDir, ".omcustomrc.json");
   if (!await fileExists(configPath)) {
     return null;
   }
@@ -13517,11 +13784,11 @@ 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
 import { readFile as fsReadFile, writeFile as fsWriteFile, rename } from "node:fs/promises";
-import { basename, join as join4 } from "node:path";
+import { basename, join as join5 } from "node:path";
 
 // src/core/git-workflow.ts
 import { execFileSync } from "node:child_process";
@@ -13777,7 +14044,7 @@ function getDefaultWorkflow() {
 var DEFAULT_LANGUAGE2 = "en";
 function getTemplateDir() {
   const packageRoot = getPackageRoot();
-  return join4(packageRoot, "templates");
+  return join5(packageRoot, "templates");
 }
 function createInstallResult(targetDir) {
   return {
@@ -13889,7 +14156,7 @@ async function installComponent(targetDir, provider, component, options) {
   if (!templatePath) {
     return false;
   }
-  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 });
@@ -13917,7 +14184,7 @@ async function installEntryDoc(targetDir, provider, language, overwrite = false)
   const layout = getProviderLayout(provider);
   const templateFile = getEntryTemplateName(provider, 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;
@@ -13938,7 +14205,7 @@ async function installEntryDoc(targetDir, provider, language, overwrite = false)
 }
 async function backupExisting(sourcePath, backupDir) {
   const name = basename(sourcePath);
-  const backupPath = join4(backupDir, name);
+  const backupPath = join5(backupDir, name);
   await rename(sourcePath, backupPath);
   return backupPath;
 }
@@ -13947,7 +14214,7 @@ async function checkExistingPaths(targetDir, provider) {
   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);
     }
@@ -13961,11 +14228,11 @@ async function backupExistingInstallation(targetDir, provider) {
     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);
@@ -13979,14 +14246,14 @@ async function backupExistingInstallation(targetDir, provider) {
 }
 
 // src/core/mcp-config.ts
-import { execSync as execSync2 } from "node:child_process";
+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, provider) {
   const layout = getProviderLayout(provider);
-  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;
   }
@@ -14025,7 +14292,7 @@ async function generateMCPConfig(targetDir, provider) {
 }
 async function checkPythonAvailable() {
   try {
-    execSync2("python --version", { stdio: "pipe" });
+    execSync3("python --version", { stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -14035,20 +14302,20 @@ async function checkPythonAvailable() {
 // src/cli/init.ts
 async function checkExistingInstallation(targetDir, provider) {
   const layout = getProviderLayout(provider);
-  const rootDir = join6(targetDir, layout.rootDir);
+  const rootDir = join7(targetDir, layout.rootDir);
   return fileExists(rootDir);
 }
 var PROVIDER_SUBDIR_COMPONENTS = new Set(["rules", "hooks", "contexts", "agents", "skills"]);
 function componentToPath(targetDir, provider, component) {
   if (component === "entry-md") {
     const layout = getProviderLayout(provider);
-    return join6(targetDir, layout.entryFile);
+    return join7(targetDir, layout.entryFile);
   }
   if (PROVIDER_SUBDIR_COMPONENTS.has(component)) {
     const layout = getProviderLayout(provider);
-    return join6(targetDir, layout.rootDir, component);
+    return join7(targetDir, layout.rootDir, component);
   }
-  return join6(targetDir, component);
+  return join7(targetDir, component);
 }
 function buildInstalledPaths(targetDir, provider, components) {
   return components.map((component) => componentToPath(targetDir, provider, component));
@@ -14130,7 +14397,7 @@ async function initCommand(options) {
 }
 
 // src/cli/list.ts
-import { basename as basename2, dirname as dirname2, join as join7, relative as relative2 } from "node:path";
+import { basename as basename2, dirname as dirname3, join as join8, relative as relative2 } from "node:path";
 var ALLOWED_TOP_LEVEL_KEYS = new Set(["name", "type", "description", "version", "category"]);
 function parseKeyValue(line) {
   const colonIndex = line.indexOf(":");
@@ -14194,12 +14461,12 @@ 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";
 }
@@ -14293,7 +14560,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 {
@@ -14321,7 +14588,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 {
@@ -14330,8 +14597,8 @@ async function getSkills(targetDir, rootDir = ".claude", config) {
     const customSkillPaths = new Set(customComponents.filter((c) => c.type === "skill").map((c) => c.path));
     const skillMdFiles = await listFiles(skillsDir, { recursive: true, pattern: "SKILL.md" });
     const skills = await Promise.all(skillMdFiles.map(async (skillMdPath) => {
-      const skillDir = dirname2(skillMdPath);
-      const indexYamlPath = join7(skillDir, "index.yaml");
+      const skillDir = dirname3(skillMdPath);
+      const indexYamlPath = join8(skillDir, "index.yaml");
       const { description, version } = await tryReadIndexYamlMetadata(indexYamlPath);
       const relativePath = relative2(targetDir, skillDir);
       return {
@@ -14350,7 +14617,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 {
@@ -14377,7 +14644,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 {
@@ -14449,7 +14716,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 {
@@ -14467,7 +14734,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 {
@@ -14552,7 +14819,7 @@ async function listCommand(type = "all", options = {}) {
 }
 
 // src/core/updater.ts
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 
 // src/core/entry-merger.ts
 var MANAGED_START = "<!-- omcustom:start -->";
@@ -14804,7 +15071,7 @@ function resolveCustomizations(customizations, configPreserveFiles, targetDir) {
 }
 async function updateEntryDoc(targetDir, provider, config, options) {
   const layout = getProviderLayout(provider);
-  const entryPath = join8(targetDir, layout.entryFile);
+  const entryPath = join9(targetDir, layout.entryFile);
   const templateName = getEntryTemplateName2(provider, config.language);
   const templatePath = resolveTemplatePath(templateName);
   if (!await fileExists(templatePath)) {
@@ -14927,7 +15194,7 @@ async function updateComponent(targetDir, provider, component, customizations, o
   const preservedFiles = [];
   const componentPath = getComponentPath2(provider, 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) {
@@ -14941,7 +15208,7 @@ async function updateComponent(targetDir, provider, component, customizations, o
     }
   }
   const path2 = await import("node:path");
-  const normalizedSkipPaths = skipPaths.map((p) => path2.relative(destPath, join8(targetDir, p)));
+  const normalizedSkipPaths = skipPaths.map((p) => path2.relative(destPath, join9(targetDir, p)));
   await copyDirectory(srcPath, destPath, {
     overwrite: true,
     skipPaths: normalizedSkipPaths.length > 0 ? normalizedSkipPaths : undefined
@@ -14961,26 +15228,26 @@ function getComponentPath2(provider, component) {
 }
 async function backupInstallation(targetDir, provider) {
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-  const backupDir = join8(targetDir, `.omcustom-backup-${timestamp}`);
+  const backupDir = join9(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 = 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 fs2.copyFile(entryPath, join8(backupDir, layout.entryFile));
+    await fs2.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);
   }
@@ -15093,9 +15360,15 @@ 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) => {
+  program2.hook("preAction", async (thisCommand, actionCommand) => {
     const opts = thisCommand.optsWithGlobals();
     const skipCheck = opts.skipVersionCheck || false;
+    if (actionCommand.name() === "init") {
+      await maybeHandleSelfUpdateForInit({
+        currentVersion: packageJson.version,
+        skip: skipCheck
+      });
+    }
     const result = await runPreflightCheck({ skip: skipCheck });
     if (result.hasUpdates) {
       const warnings = formatPreflightWarnings(result);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-customcode",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "description": "Batteries-included agent harness for Claude Code and OpenAI Codex",
   "type": "module",
   "bin": {