oh-my-customcode 0.12.0 → 0.12.2

package/dist/cli/index.js

@@ -9153,7 +9153,7 @@ function checkOutdated(tools) {
   } catch {}
 }
 async function runPreflightCheck(options = {}) {
-  const { skip = false, tools: toolNames = ["claude-code", "codex"], timeout = 5000 } = options;
+  const { skip = false, tools: toolNames = ["claude-code"], timeout = 5000 } = options;
   if (skip) {
     return {
       tools: [],
@@ -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 = () => {
@@ -11680,10 +11687,21 @@ 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)",
-      providerOption: "Provider to initialize (auto, claude, codex)",
       start: "Initializing oh-my-customcode...",
       exists: "Existing {{rootDir}} directory found.",
       backing_up: "Creating backup...",
@@ -11733,7 +11751,6 @@ var en_default = {
       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)",
@@ -11746,7 +11763,6 @@ var en_default = {
     list: {
       description: "List installed components",
       typeArgument: "Type to list: agents, skills, guides, rules, or all",
-      providerOption: "Provider to list (auto, claude, codex)",
       scanning: "Scanning installed components...",
       empty: "No {{type}} found.",
       header: "{{type}} ({{count}} installed)",
@@ -11771,7 +11787,6 @@ var en_default = {
     doctor: {
       description: "Check and fix configuration issues",
       fixOption: "Automatically fix issues that can be fixed",
-      providerOption: "Provider to diagnose (auto, claude, codex)",
       checking: "Running diagnostic checks...",
       applyingFixes: "Applying fixes...",
       fixing: "Fixing: {{name}}...",
@@ -11964,10 +11979,21 @@ 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)",
-      providerOption: "초기화할 제공자 (auto, claude, codex)",
       start: "oh-my-customcode 초기화 중...",
       exists: "기존 {{rootDir}} 디렉토리가 발견되었습니다.",
       backing_up: "백업을 생성합니다...",
@@ -12017,7 +12043,6 @@ var ko_default = {
       guidesOption: "가이드만 업데이트",
       hooksOption: "훅만 업데이트",
       contextsOption: "컨텍스트만 업데이트",
-      providerOption: "업데이트할 제공자 (auto, claude, codex)",
       dryRunHeader: "드라이 런 - 변경사항 없음:",
       componentUpdated: "✓ {{component}} 업데이트됨",
       componentSkipped: "- {{component}} 건너뜀 (변경사항 없음)",
@@ -12030,7 +12055,6 @@ var ko_default = {
     list: {
       description: "설치된 컴포넌트 목록 표시",
       typeArgument: "표시할 타입: agents, skills, guides, rules 또는 all",
-      providerOption: "표시할 제공자 (auto, claude, codex)",
       scanning: "설치된 컴포넌트 검색 중...",
       empty: "{{type}}이(가) 없습니다.",
       header: "{{type}} ({{count}}개 설치됨)",
@@ -12055,7 +12079,6 @@ var ko_default = {
     doctor: {
       description: "설정 문제 확인 및 수정",
       fixOption: "자동으로 수정 가능한 문제 수정",
-      providerOption: "진단할 제공자 (auto, claude, codex)",
       checking: "진단 검사 실행 중...",
       applyingFixes: "수정 사항 적용 중...",
       fixing: "수정 중: {{name}}...",
@@ -12247,6 +12270,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 +12557,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 +12713,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");
@@ -12689,7 +12948,6 @@ function getDefaultConfig() {
     configVersion: CURRENT_CONFIG_VERSION,
     version: "0.0.0",
     language: "en",
-    provider: "auto",
     installedAt: "",
     lastUpdated: "",
     installedComponents: [],
@@ -12716,7 +12974,7 @@ function getDefaultPreferences() {
   };
 }
 function getConfigPath(targetDir) {
-  return join2(targetDir, CONFIG_FILE);
+  return join3(targetDir, CONFIG_FILE);
 }
 async function loadConfig(targetDir) {
   const configPath = getConfigPath(targetDir);
@@ -12812,203 +13070,36 @@ function migrateConfig(config) {
 }
 
 // src/core/layout.ts
-var PROVIDER_LAYOUTS = {
-  claude: {
-    provider: "claude",
-    rootDir: ".claude",
-    entryFile: "CLAUDE.md",
-    entryTemplatePrefix: "CLAUDE.md",
-    manifestFile: "manifest.json",
-    backupDirPrefix: ".claude-backup-",
-    directoryStructure: [
-      ".claude",
-      ".claude/rules",
-      ".claude/hooks",
-      ".claude/contexts",
-      ".claude/agents",
-      ".claude/skills",
-      "guides"
-    ]
-  },
-  codex: {
-    provider: "codex",
-    rootDir: ".codex",
-    entryFile: "AGENTS.md",
-    entryTemplatePrefix: "AGENTS.md",
-    manifestFile: "manifest.codex.json",
-    backupDirPrefix: ".codex-backup-",
-    directoryStructure: [
-      ".codex",
-      ".codex/rules",
-      ".codex/hooks",
-      ".codex/contexts",
-      ".codex/agents",
-      ".codex/skills",
-      "guides"
-    ]
-  }
+var CLAUDE_LAYOUT = {
+  rootDir: ".claude",
+  entryFile: "CLAUDE.md",
+  entryTemplatePrefix: "CLAUDE.md",
+  manifestFile: "manifest.json",
+  backupDirPrefix: ".claude-backup-",
+  directoryStructure: [
+    ".claude",
+    ".claude/rules",
+    ".claude/hooks",
+    ".claude/contexts",
+    ".claude/agents",
+    ".claude/skills",
+    "guides"
+  ]
 };
-function getProviderLayout(provider) {
-  return PROVIDER_LAYOUTS[provider];
+function getProviderLayout() {
+  return CLAUDE_LAYOUT;
 }
-function getEntryTemplateName(provider, language) {
-  const layout = getProviderLayout(provider);
-  return `${layout.entryTemplatePrefix}.${language}`;
+function getEntryTemplateName(language) {
+  return `CLAUDE.md.${language}`;
 }
-function getComponentPath(provider, component) {
-  const layout = getProviderLayout(provider);
+function getComponentPath(component) {
   if (component === "entry-md") {
-    return layout.entryFile;
+    return "CLAUDE.md";
   }
   if (component === "guides") {
     return "guides";
   }
-  return `${layout.rootDir}/${component}`;
-}
-function getDefaultProvider() {
-  return "claude";
-}
-
-// src/core/provider.ts
-import { join as join3 } from "node:path";
-var ENV_SIGNALS = {
-  claude: [
-    "ANTHROPIC_API_KEY",
-    "CLAUDE_CODE",
-    "CLAUDE_CODE_EFFORT_LEVEL",
-    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS",
-    "CLAUDE_CODE_ENABLE_TELEMETRY"
-  ],
-  codex: ["OPENAI_API_KEY", "OPENAI_ORG_ID", "OPENAI_PROJECT", "CODEX_HOME", "CODEX_PROJECT"]
-};
-var PROVIDER_ENV_OVERRIDES = ["OMCUSTOM_PROVIDER", "LLM_SERVICE"];
-function normalizeProvider(value) {
-  if (!value)
-    return null;
-  const normalized = value.toLowerCase().trim();
-  if (normalized === "claude" || normalized === "codex" || normalized === "auto") {
-    return normalized;
-  }
-  return null;
-}
-function detectFromEnv(env) {
-  for (const key of PROVIDER_ENV_OVERRIDES) {
-    const override = normalizeProvider(env[key]);
-    if (override && override !== "auto") {
-      return {
-        provider: override,
-        source: "override",
-        confidence: "high",
-        reason: `env:${key}`
-      };
-    }
-  }
-  const claudeSignals = ENV_SIGNALS.claude.filter((key) => Boolean(env[key]));
-  const codexSignals = ENV_SIGNALS.codex.filter((key) => Boolean(env[key]));
-  const hasClaude = claudeSignals.length > 0;
-  const hasCodex = codexSignals.length > 0;
-  if (hasClaude && !hasCodex) {
-    return {
-      provider: "claude",
-      source: "env",
-      confidence: "medium",
-      reason: `env:${claudeSignals[0]}`
-    };
-  }
-  if (hasCodex && !hasClaude) {
-    return {
-      provider: "codex",
-      source: "env",
-      confidence: "medium",
-      reason: `env:${codexSignals[0]}`
-    };
-  }
-  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 claudeFound = await Promise.all(claudeMarkers.map((path) => fileExists(path)));
-  const codexFound = await Promise.all(codexMarkers.map((path) => fileExists(path)));
-  const hasClaude = claudeFound.some(Boolean);
-  const hasCodex = codexFound.some(Boolean);
-  if (hasClaude && !hasCodex) {
-    return {
-      provider: "claude",
-      source: "project",
-      confidence: "medium",
-      reason: "project:claude"
-    };
-  }
-  if (hasCodex && !hasClaude) {
-    return {
-      provider: "codex",
-      source: "project",
-      confidence: "medium",
-      reason: "project:codex"
-    };
-  }
-  return null;
-}
-async function detectFromConfig(targetDir) {
-  const configPath = join3(targetDir, ".omcustomrc.json");
-  if (!await fileExists(configPath)) {
-    return null;
-  }
-  try {
-    const config = await readJsonFile(configPath);
-    const provider = normalizeProvider(config.provider);
-    if (provider && provider !== "auto") {
-      return {
-        provider,
-        source: "config",
-        confidence: "high",
-        reason: "config:provider"
-      };
-    }
-  } catch {}
-  return null;
-}
-async function detectProvider(options = {}) {
-  const env = options.env ?? process.env;
-  const override = options.override;
-  const normalizedOverride = normalizeProvider(override);
-  if (normalizedOverride && normalizedOverride !== "auto") {
-    return {
-      provider: normalizedOverride,
-      source: "override",
-      confidence: "high",
-      reason: "override:option"
-    };
-  }
-  if (options.targetDir) {
-    const fromConfig = await detectFromConfig(options.targetDir);
-    if (fromConfig) {
-      return fromConfig;
-    }
-  }
-  if (options.targetDir && options.preferProject) {
-    const fromProject = await detectFromProject(options.targetDir);
-    if (fromProject) {
-      return fromProject;
-    }
-  }
-  const fromEnv = detectFromEnv(env);
-  if (fromEnv) {
-    return fromEnv;
-  }
-  if (options.targetDir && !options.preferProject) {
-    const fromProject = await detectFromProject(options.targetDir);
-    if (fromProject) {
-      return fromProject;
-    }
-  }
-  return {
-    provider: getDefaultProvider(),
-    source: "default",
-    confidence: "low",
-    reason: "default"
-  };
+  return `.claude/${component}`;
 }
 
 // src/cli/doctor.ts
@@ -13452,12 +13543,7 @@ async function doctorCommand(options = {}) {
   const targetDir = process.cwd();
   console.log(i18n.t("cli.doctor.checking"));
   console.log("");
-  const detection = await detectProvider({
-    targetDir,
-    override: options.provider,
-    preferProject: true
-  });
-  const layout = getProviderLayout(detection.provider);
+  const layout = getProviderLayout();
   let checks = await Promise.all([
     checkEntryDoc(targetDir, layout.entryFile),
     checkRules(targetDir, layout.rootDir),
@@ -13795,21 +13881,21 @@ async function ensureTargetDirectory(targetDir) {
     await ensureDirectory(targetDir);
   }
 }
-async function handleBackup(targetDir, provider, shouldBackup, result) {
+async function handleBackup(targetDir, shouldBackup, result) {
   if (!shouldBackup)
     return;
-  const backupPaths = await backupExistingInstallation(targetDir, provider);
+  const backupPaths = await backupExistingInstallation(targetDir);
   result.backedUpPaths.push(...backupPaths);
   if (backupPaths.length > 0) {
     info("install.backup", { path: backupPaths[0] });
   }
 }
-async function checkAndWarnExisting(targetDir, provider, force, backup, result) {
+async function checkAndWarnExisting(targetDir, force, backup, result) {
   if (force || backup)
     return;
-  const existingPaths = await checkExistingPaths(targetDir, provider);
+  const existingPaths = await checkExistingPaths(targetDir);
   if (existingPaths.length > 0) {
-    const layout = getProviderLayout(provider);
+    const layout = getProviderLayout();
     warn("install.exists", { rootDir: layout.rootDir });
     result.warnings.push(`Existing files found: ${existingPaths.join(", ")}. Use --force to overwrite or --backup to backup first.`);
   }
@@ -13820,15 +13906,15 @@ async function verifyTemplateDirectory() {
     throw new Error(`Template directory not found: ${templateDir}`);
   }
 }
-async function installAllComponents(targetDir, provider, options, result) {
+async function installAllComponents(targetDir, options, result) {
   const components = options.components || getAllComponents();
   for (const component of components) {
-    await installSingleComponent(targetDir, provider, component, options, result);
+    await installSingleComponent(targetDir, component, options, result);
   }
 }
-async function installSingleComponent(targetDir, provider, component, options, result) {
+async function installSingleComponent(targetDir, component, options, result) {
   try {
-    const installed = await installComponent(targetDir, provider, component, options);
+    const installed = await installComponent(targetDir, component, options);
     if (installed) {
       result.installedComponents.push(component);
     } else {
@@ -13839,36 +13925,34 @@ async function installSingleComponent(targetDir, provider, component, options, r
     result.warnings.push(`Failed to install ${component}: ${message}`);
   }
 }
-async function installEntryDocWithTracking(targetDir, provider, options, result) {
+async function installEntryDocWithTracking(targetDir, options, result) {
   const language = options.language ?? DEFAULT_LANGUAGE2;
   const overwrite = !!(options.force || options.backup);
-  const installed = await installEntryDoc(targetDir, provider, language, overwrite);
+  const installed = await installEntryDoc(targetDir, language, overwrite);
   if (installed) {
     result.installedComponents.push("entry-md");
   } else {
     result.skippedComponents.push("entry-md");
   }
 }
-async function updateInstallConfig(targetDir, provider, options, installedComponents) {
+async function updateInstallConfig(targetDir, options, installedComponents) {
   const config = await loadConfig(targetDir);
   config.language = options.language ?? DEFAULT_LANGUAGE2;
-  config.provider = provider;
   config.installedAt = new Date().toISOString();
   config.installedComponents = installedComponents;
   await saveConfig(targetDir, config);
 }
 async function install(options) {
   const result = createInstallResult(options.targetDir);
-  const provider = options.provider ?? "claude";
   try {
     info("install.start", { targetDir: options.targetDir });
     await ensureTargetDirectory(options.targetDir);
-    await handleBackup(options.targetDir, provider, !!options.backup, result);
-    await checkAndWarnExisting(options.targetDir, provider, !!options.force, !!options.backup, result);
+    await handleBackup(options.targetDir, !!options.backup, result);
+    await checkAndWarnExisting(options.targetDir, !!options.force, !!options.backup, result);
     await verifyTemplateDirectory();
-    await installAllComponents(options.targetDir, provider, options, result);
-    await installEntryDocWithTracking(options.targetDir, provider, options, result);
-    await updateInstallConfig(options.targetDir, provider, options, result.installedComponents);
+    await installAllComponents(options.targetDir, options, result);
+    await installEntryDocWithTracking(options.targetDir, options, result);
+    await updateInstallConfig(options.targetDir, options, result.installedComponents);
     result.success = true;
     success("install.success");
   } catch (err) {
@@ -13881,11 +13965,11 @@ async function install(options) {
 function getAllComponents() {
   return ["rules", "agents", "skills", "guides", "hooks", "contexts"];
 }
-async function installComponent(targetDir, provider, component, options) {
+async function installComponent(targetDir, component, options) {
   if (component === "entry-md") {
     return false;
   }
-  const templatePath = getComponentPath(provider, component);
+  const templatePath = getComponentPath(component);
   if (!templatePath) {
     return false;
   }
@@ -13913,9 +13997,9 @@ function renderGitWorkflowSection(targetDir, language) {
   const result = detectGitWorkflow(targetDir) ?? getDefaultWorkflow();
   return language === "ko" ? renderGitWorkflowKO(result) : renderGitWorkflowEN(result);
 }
-async function installEntryDoc(targetDir, provider, language, overwrite = false) {
-  const layout = getProviderLayout(provider);
-  const templateFile = getEntryTemplateName(provider, language);
+async function installEntryDoc(targetDir, language, overwrite = false) {
+  const layout = getProviderLayout();
+  const templateFile = getEntryTemplateName(language);
   const srcPath = resolveTemplatePath(templateFile);
   const destPath = join4(targetDir, layout.entryFile);
   if (!await fileExists(srcPath)) {
@@ -13942,8 +14026,8 @@ async function backupExisting(sourcePath, backupDir) {
   await rename(sourcePath, backupPath);
   return backupPath;
 }
-async function checkExistingPaths(targetDir, provider) {
-  const layout = getProviderLayout(provider);
+async function checkExistingPaths(targetDir) {
+  const layout = getProviderLayout();
   const pathsToCheck = [layout.entryFile, layout.rootDir, "guides"];
   const existingPaths = [];
   for (const relativePath of pathsToCheck) {
@@ -13954,9 +14038,9 @@ async function checkExistingPaths(targetDir, provider) {
   }
   return existingPaths;
 }
-async function backupExistingInstallation(targetDir, provider) {
-  const layout = getProviderLayout(provider);
-  const existingPaths = await checkExistingPaths(targetDir, provider);
+async function backupExistingInstallation(targetDir) {
+  const layout = getProviderLayout();
+  const existingPaths = await checkExistingPaths(targetDir);
   if (existingPaths.length === 0) {
     return [];
   }
@@ -13979,11 +14063,11 @@ 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";
-async function generateMCPConfig(targetDir, provider) {
-  const layout = getProviderLayout(provider);
+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));
@@ -14025,7 +14109,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;
@@ -14033,25 +14117,25 @@ async function checkPythonAvailable() {
 }
 
 // src/cli/init.ts
-async function checkExistingInstallation(targetDir, provider) {
-  const layout = getProviderLayout(provider);
+async function checkExistingInstallation(targetDir) {
+  const layout = getProviderLayout();
   const rootDir = join6(targetDir, layout.rootDir);
   return fileExists(rootDir);
 }
 var PROVIDER_SUBDIR_COMPONENTS = new Set(["rules", "hooks", "contexts", "agents", "skills"]);
-function componentToPath(targetDir, provider, component) {
+function componentToPath(targetDir, component) {
   if (component === "entry-md") {
-    const layout = getProviderLayout(provider);
+    const layout = getProviderLayout();
     return join6(targetDir, layout.entryFile);
   }
   if (PROVIDER_SUBDIR_COMPONENTS.has(component)) {
-    const layout = getProviderLayout(provider);
+    const layout = getProviderLayout();
     return join6(targetDir, layout.rootDir, component);
   }
   return join6(targetDir, component);
 }
-function buildInstalledPaths(targetDir, provider, components) {
-  return components.map((component) => componentToPath(targetDir, provider, component));
+function buildInstalledPaths(targetDir, components) {
+  return components.map((component) => componentToPath(targetDir, component));
 }
 function logItems(items, formatter) {
   for (const item of items) {
@@ -14084,10 +14168,8 @@ async function initCommand(options) {
   const targetDir = process.cwd();
   console.log(i18n.t("cli.init.start"));
   try {
-    const detection = await detectProvider({ targetDir, override: options.provider });
-    const provider = detection.provider;
-    const layout = getProviderLayout(provider);
-    const exists2 = await checkExistingInstallation(targetDir, provider);
+    const layout = getProviderLayout();
+    const exists2 = await checkExistingInstallation(targetDir);
     if (exists2) {
       console.log(i18n.t("cli.init.exists", { rootDir: layout.rootDir }));
       console.log(i18n.t("cli.init.backing_up"));
@@ -14096,20 +14178,19 @@ async function initCommand(options) {
     const installResult = await install({
       targetDir,
       language: options.lang,
-      provider,
       force: options.force ?? false,
       backup: exists2
     });
     if (!installResult.success) {
       return createFailureResult(installResult.error || "Unknown error");
     }
-    const installedPaths = buildInstalledPaths(targetDir, provider, installResult.installedComponents);
+    const installedPaths = buildInstalledPaths(targetDir, installResult.installedComponents);
     logInstallResultInfo(installResult);
     logSuccessDetails(installedPaths, installResult.skippedComponents);
     const pythonAvailable = await checkPythonAvailable();
     if (pythonAvailable) {
       try {
-        await generateMCPConfig(targetDir, provider);
+        await generateMCPConfig(targetDir);
       } catch {
         console.warn("Warning: Failed to generate MCP config. You can configure it manually.");
       }
@@ -14130,7 +14211,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 join7, 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(":");
@@ -14330,7 +14411,7 @@ 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 skillDir = dirname3(skillMdPath);
       const indexYamlPath = join7(skillDir, "index.yaml");
       const { description, version } = await tryReadIndexYamlMetadata(indexYamlPath);
       const relativePath = relative2(targetDir, skillDir);
@@ -14530,12 +14611,7 @@ async function listCommand(type = "all", options = {}) {
   const format = options.format || "table";
   console.log(i18n.t("cli.list.scanning"));
   try {
-    const detection = await detectProvider({
-      targetDir,
-      override: options.provider,
-      preferProject: true
-    });
-    const layout = getProviderLayout(detection.provider);
+    const layout = getProviderLayout();
     const config = await loadConfig(targetDir);
     const components = type === "all" ? await handleListAll(targetDir, layout.rootDir, format, config) : await COMPONENT_GETTERS[type](targetDir, layout.rootDir, config);
     if (type === "all" && format === "json") {
@@ -14684,14 +14760,14 @@ function createUpdateResult() {
     warnings: []
   };
 }
-async function handleBackupIfRequested(targetDir, provider, backup, result) {
+async function handleBackupIfRequested(targetDir, backup, result) {
   if (!backup)
     return;
-  const backupPath = await backupInstallation(targetDir, provider);
+  const backupPath = await backupInstallation(targetDir);
   result.backedUpPaths.push(backupPath);
   info("update.backup_created", { path: backupPath });
 }
-async function processComponentUpdate(targetDir, provider, component, updateCheck, customizations, options, result, config) {
+async function processComponentUpdate(targetDir, component, updateCheck, customizations, options, result, config) {
   const componentUpdate = updateCheck.updatableComponents.find((c) => c.name === component);
   if (!componentUpdate && !options.force) {
     result.skippedComponents.push(component);
@@ -14703,7 +14779,7 @@ async function processComponentUpdate(targetDir, provider, component, updateChec
     return;
   }
   try {
-    const preserved = await updateComponent(targetDir, provider, component, customizations, options, config);
+    const preserved = await updateComponent(targetDir, component, customizations, options, config);
     result.updatedComponents.push(component);
     result.preservedFiles.push(...preserved);
   } catch (err) {
@@ -14712,13 +14788,13 @@ async function processComponentUpdate(targetDir, provider, component, updateChec
     result.skippedComponents.push(component);
   }
 }
-async function updateAllComponents(targetDir, provider, components, updateCheck, customizations, options, result, config) {
+async function updateAllComponents(targetDir, components, updateCheck, customizations, options, result, config) {
   for (const component of components) {
-    await processComponentUpdate(targetDir, provider, component, updateCheck, customizations, options, result, config);
+    await processComponentUpdate(targetDir, component, updateCheck, customizations, options, result, config);
   }
 }
-function getEntryTemplateName2(provider, language) {
-  const layout = getProviderLayout(provider);
+function getEntryTemplateName2(language) {
+  const layout = getProviderLayout();
   const baseName = layout.entryFile.replace(".md", "");
   return language === "ko" ? `${baseName}.md.ko` : `${baseName}.md.en`;
 }
@@ -14802,10 +14878,10 @@ function resolveCustomizations(customizations, configPreserveFiles, targetDir) {
   }
   return null;
 }
-async function updateEntryDoc(targetDir, provider, config, options) {
-  const layout = getProviderLayout(provider);
+async function updateEntryDoc(targetDir, config, options) {
+  const layout = getProviderLayout();
   const entryPath = join8(targetDir, layout.entryFile);
-  const templateName = getEntryTemplateName2(provider, config.language);
+  const templateName = getEntryTemplateName2(config.language);
   const templatePath = resolveTemplatePath(templateName);
   if (!await fileExists(templatePath)) {
     warn("update.entry_template_not_found", { template: templateName });
@@ -14842,9 +14918,8 @@ async function update(options) {
   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);
+    const updateCheck = await checkForUpdates(options.targetDir);
     result.newVersion = updateCheck.latestVersion;
     if (!updateCheck.hasUpdates && !options.force) {
       info("update.no_updates");
@@ -14852,14 +14927,14 @@ async function update(options) {
       result.skippedComponents = options.components || getAllUpdateComponents();
       return result;
     }
-    await handleBackupIfRequested(options.targetDir, provider, !!options.backup, result);
+    await handleBackupIfRequested(options.targetDir, !!options.backup, result);
     const manifestCustomizations = await resolveManifestCustomizations(options, options.targetDir);
     const configPreserveFiles = resolveConfigPreserveFiles(options, config);
     const customizations = resolveCustomizations(manifestCustomizations, configPreserveFiles, options.targetDir);
     const components = options.components || getAllUpdateComponents();
-    await updateAllComponents(options.targetDir, provider, components, updateCheck, customizations, options, result, config);
+    await updateAllComponents(options.targetDir, components, updateCheck, customizations, options, result, config);
     if (!options.components || options.components.length === 0) {
-      await updateEntryDoc(options.targetDir, provider, config, options);
+      await updateEntryDoc(options.targetDir, config, options);
     }
     config.version = result.newVersion;
     config.lastUpdated = new Date().toISOString();
@@ -14880,13 +14955,13 @@ async function update(options) {
   }
   return result;
 }
-async function checkForUpdates(targetDir, provider = "claude") {
+async function checkForUpdates(targetDir) {
   const config = await loadConfig(targetDir);
   const currentVersion = config.version;
-  const latestVersion = await getLatestVersion(provider);
+  const latestVersion = await getLatestVersion();
   const updatableComponents = [];
   for (const component of getAllUpdateComponents()) {
-    const hasUpdate = await componentHasUpdate(targetDir, provider, component, config);
+    const hasUpdate = await componentHasUpdate(targetDir, component, config);
     if (hasUpdate) {
       updatableComponents.push({
         name: component,
@@ -14906,8 +14981,8 @@ async function checkForUpdates(targetDir, provider = "claude") {
 function getAllUpdateComponents() {
   return ["rules", "agents", "skills", "guides", "hooks", "contexts"];
 }
-async function getLatestVersion(provider) {
-  const layout = getProviderLayout(provider);
+async function getLatestVersion() {
+  const layout = getProviderLayout();
   const manifestPath = resolveTemplatePath(layout.manifestFile);
   if (await fileExists(manifestPath)) {
     const manifest = await readJsonFile(manifestPath);
@@ -14915,17 +14990,17 @@ async function getLatestVersion(provider) {
   }
   return "0.0.0";
 }
-async function componentHasUpdate(_targetDir, provider, component, config) {
+async function componentHasUpdate(_targetDir, component, config) {
   const installedVersion = config.componentVersions?.[component];
   if (!installedVersion) {
     return true;
   }
-  const latestVersion = await getLatestVersion(provider);
+  const latestVersion = await getLatestVersion();
   return installedVersion !== latestVersion;
 }
-async function updateComponent(targetDir, provider, component, customizations, options, config) {
+async function updateComponent(targetDir, component, customizations, options, config) {
   const preservedFiles = [];
-  const componentPath = getComponentPath2(provider, component);
+  const componentPath = getComponentPath2(component);
   const srcPath = resolveTemplatePath(componentPath);
   const destPath = join8(targetDir, componentPath);
   const customComponents = config.customComponents || [];
@@ -14952,19 +15027,19 @@ async function updateComponent(targetDir, provider, component, customizations, o
   });
   return preservedFiles;
 }
-function getComponentPath2(provider, component) {
-  const layout = getProviderLayout(provider);
+function getComponentPath2(component) {
+  const layout = getProviderLayout();
   if (component === "guides") {
     return "guides";
   }
   return `${layout.rootDir}/${component}`;
 }
-async function backupInstallation(targetDir, provider) {
+async function backupInstallation(targetDir) {
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
   const backupDir = join8(targetDir, `.omcustom-backup-${timestamp}`);
   const fs2 = await import("node:fs/promises");
   await ensureDirectory(backupDir);
-  const layout = getProviderLayout(provider);
+  const layout = getProviderLayout();
   const dirsToBackup = [layout.rootDir, "guides"];
   for (const dir2 of dirsToBackup) {
     const srcPath = join8(targetDir, dir2);
@@ -14991,18 +15066,12 @@ async function loadCustomizationManifest(targetDir) {
 async function updateCommand(options = {}) {
   try {
     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"));
     }
     const updateOptions = {
       targetDir,
-      provider,
       components,
       force: options.force,
       preserveCustomizations: true,
@@ -15077,25 +15146,30 @@ 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")).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) => {
+  program2.command("init").description(i18n.t("cli.init.description")).option("-l, --lang <language>", i18n.t("cli.init.langOption"), "en").action(async (options) => {
     await initCommand(options);
   });
-  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("--force-overwrite-all", i18n.t("cli.update.forceOverwriteAllOption")).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) => {
+  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("--force-overwrite-all", i18n.t("cli.update.forceOverwriteAllOption")).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")).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) => {
+  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").action(async (type, options) => {
     await listCommand(type, {
       format: options.format,
-      verbose: options.verbose,
-      provider: options.provider
+      verbose: options.verbose
     });
   });
-  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) => {
+  program2.command("doctor").description(i18n.t("cli.doctor.description")).option("--fix", i18n.t("cli.doctor.fixOption")).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);