oh-my-customcode 0.12.1 → 0.12.3

package/dist/index.js

@@ -384,7 +384,6 @@ function getDefaultConfig() {
     configVersion: CURRENT_CONFIG_VERSION,
     version: "0.0.0",
     language: "en",
-    provider: "auto",
     installedAt: "",
     lastUpdated: "",
     installedComponents: [],
@@ -759,61 +758,36 @@ import { readFile as fsReadFile, writeFile as fsWriteFile, rename } from "node:f
 import { basename, join as join3 } from "node:path";
 
 // 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";
+  return `.claude/${component}`;
 }
 
 // src/core/installer.ts
@@ -838,21 +812,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.`);
   }
@@ -863,15 +837,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 {
@@ -882,36 +856,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_LANGUAGE;
   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_LANGUAGE;
-  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) {
@@ -930,16 +902,16 @@ async function copyTemplates(targetDir, templatePath, options) {
     preserveTimestamps: true
   });
 }
-async function createDirectoryStructure(targetDir, provider = "claude") {
-  const layout = getProviderLayout(provider);
+async function createDirectoryStructure(targetDir) {
+  const layout = getProviderLayout();
   for (const dir of layout.directoryStructure) {
     const fullPath = join3(targetDir, dir);
     await ensureDirectory(fullPath);
   }
 }
-async function getTemplateManifest(provider = "claude") {
+async function getTemplateManifest() {
   const packageRoot = getPackageRoot();
-  const layout = getProviderLayout(provider);
+  const layout = getProviderLayout();
   const manifestPath = join3(packageRoot, "templates", layout.manifestFile);
   if (await fileExists(manifestPath)) {
     return readJsonFile(manifestPath);
@@ -949,7 +921,7 @@ async function getTemplateManifest(provider = "claude") {
     lastUpdated: new Date().toISOString(),
     components: getAllComponents().map((name) => ({
       name,
-      path: getComponentPath(provider, name),
+      path: getComponentPath(name),
       description: `${name} component`,
       files: 0
     })),
@@ -959,11 +931,11 @@ async function getTemplateManifest(provider = "claude") {
 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;
   }
@@ -991,9 +963,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 = join3(targetDir, layout.entryFile);
   if (!await fileExists(srcPath)) {
@@ -1020,8 +992,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) {
@@ -1032,9 +1004,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 [];
   }
@@ -1056,148 +1028,16 @@ async function backupExistingInstallation(targetDir, provider) {
   return backedUpPaths.length > 0 ? [backupDir] : [];
 }
 // src/core/provider.ts
-import { join as join4 } 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 = [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);
-  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 = join4(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;
-    }
-  }
+async function detectProvider(_options = {}) {
   return {
-    provider: getDefaultProvider(),
+    provider: "claude",
     source: "default",
-    confidence: "low",
-    reason: "default"
+    confidence: "high",
+    reason: "claude-only"
   };
 }
 // src/core/updater.ts
-import { join as join5 } from "node:path";
+import { join as join4 } from "node:path";
 
 // src/core/entry-merger.ts
 var MANAGED_START = "<!-- omcustom:start -->";
@@ -1329,14 +1169,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);
@@ -1348,7 +1188,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) {
@@ -1357,13 +1197,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`;
 }
@@ -1447,10 +1287,10 @@ function resolveCustomizations(customizations, configPreserveFiles, targetDir) {
   }
   return null;
 }
-async function updateEntryDoc(targetDir, provider, config, options) {
-  const layout = getProviderLayout(provider);
-  const entryPath = join5(targetDir, layout.entryFile);
-  const templateName = getEntryTemplateName2(provider, config.language);
+async function updateEntryDoc(targetDir, config, options) {
+  const layout = getProviderLayout();
+  const entryPath = join4(targetDir, layout.entryFile);
+  const templateName = getEntryTemplateName2(config.language);
   const templatePath = resolveTemplatePath(templateName);
   if (!await fileExists(templatePath)) {
     warn("update.entry_template_not_found", { template: templateName });
@@ -1487,9 +1327,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");
@@ -1497,14 +1336,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();
@@ -1525,13 +1364,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,
@@ -1551,8 +1390,8 @@ async function checkForUpdates(targetDir, provider = "claude") {
 async function applyUpdates(targetDir, updates) {
   const fs = await import("node:fs/promises");
   for (const update2 of updates) {
-    const fullPath = join5(targetDir, update2.path);
-    await ensureDirectory(join5(fullPath, ".."));
+    const fullPath = join4(targetDir, update2.path);
+    await ensureDirectory(join4(fullPath, ".."));
     await fs.writeFile(fullPath, update2.content, "utf-8");
     debug("update.file_applied", { path: update2.path });
   }
@@ -1561,7 +1400,7 @@ async function preserveCustomizations(targetDir, customizations) {
   const preserved = new Map;
   const fs = await import("node:fs/promises");
   for (const filePath of customizations) {
-    const fullPath = join5(targetDir, filePath);
+    const fullPath = join4(targetDir, filePath);
     if (await fileExists(fullPath)) {
       const content = await fs.readFile(fullPath, "utf-8");
       preserved.set(filePath, content);
@@ -1572,8 +1411,8 @@ async function preserveCustomizations(targetDir, customizations) {
 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);
@@ -1581,19 +1420,19 @@ 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 = join5(targetDir, componentPath);
+  const destPath = join4(targetDir, componentPath);
   const customComponents = config.customComponents || [];
   const skipPaths = [];
   if (customizations && !options.forceOverwriteAll) {
@@ -1607,7 +1446,7 @@ async function updateComponent(targetDir, provider, component, customizations, o
     }
   }
   const path = await import("node:path");
-  const normalizedSkipPaths = skipPaths.map((p) => path.relative(destPath, join5(targetDir, p)));
+  const normalizedSkipPaths = skipPaths.map((p) => path.relative(destPath, join4(targetDir, p)));
   await copyDirectory(srcPath, destPath, {
     overwrite: true,
     skipPaths: normalizedSkipPaths.length > 0 ? normalizedSkipPaths : undefined
@@ -1618,35 +1457,35 @@ 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 = join5(targetDir, `.omcustom-backup-${timestamp}`);
+  const backupDir = join4(targetDir, `.omcustom-backup-${timestamp}`);
   const fs = await import("node:fs/promises");
   await ensureDirectory(backupDir);
-  const layout = getProviderLayout(provider);
+  const layout = getProviderLayout();
   const dirsToBackup = [layout.rootDir, "guides"];
   for (const dir of dirsToBackup) {
-    const srcPath = join5(targetDir, dir);
+    const srcPath = join4(targetDir, dir);
     if (await fileExists(srcPath)) {
-      const destPath = join5(backupDir, dir);
+      const destPath = join4(backupDir, dir);
       await copyDirectory(srcPath, destPath, { overwrite: true });
     }
   }
-  const entryPath = join5(targetDir, layout.entryFile);
+  const entryPath = join4(targetDir, layout.entryFile);
   if (await fileExists(entryPath)) {
-    await fs.copyFile(entryPath, join5(backupDir, layout.entryFile));
+    await fs.copyFile(entryPath, join4(backupDir, layout.entryFile));
   }
   return backupDir;
 }
 async function loadCustomizationManifest(targetDir) {
-  const manifestPath = join5(targetDir, CUSTOMIZATION_MANIFEST_FILE);
+  const manifestPath = join4(targetDir, CUSTOMIZATION_MANIFEST_FILE);
   if (await fileExists(manifestPath)) {
     return readJsonFile(manifestPath);
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "oh-my-customcode",
-  "version": "0.12.1",
-  "description": "Batteries-included agent harness for Claude Code and OpenAI Codex",
+  "version": "0.12.3",
+  "description": "Batteries-included agent harness for Claude Code",
   "type": "module",
   "bin": {
     "omcustom": "./dist/cli/index.js"
@@ -59,8 +59,6 @@
   "keywords": [
     "claude",
     "claude-code",
-    "codex",
-    "codex-cli",
     "openai",
     "ai",
     "agent",