oh-my-customcode 0.8.0 → 0.9.0

package/dist/cli/index.js

@@ -11464,8 +11464,9 @@ var en_default = {
     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 .claude/ directory found.",
+      exists: "Existing {{rootDir}} directory found.",
       backing_up: "Creating backup...",
       backedUp: "Backed up existing installation to: {{path}}",
       copying: "Copying templates...",
@@ -11507,6 +11508,7 @@ 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)",
@@ -11531,6 +11533,7 @@ 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}}...",
@@ -11571,6 +11574,10 @@ var en_default = {
           pass: "CLAUDE.md exists",
           fail: "CLAUDE.md not found"
         },
+        entryMd: {
+          pass: "{{entry}} exists",
+          fail: "{{entry}} not found"
+        },
         rules: {
           pass: "Rules directory is valid",
           fail: "Rules directory is missing or incomplete"
@@ -11711,8 +11718,9 @@ var ko_default = {
     init: {
       description: "현재 디렉토리에 oh-my-customcode 초기화",
       langOption: "템플릿 언어 (en 또는 ko)",
+      providerOption: "초기화할 제공자 (auto, claude, codex)",
       start: "oh-my-customcode 초기화 중...",
-      exists: "기존 .claude/ 디렉토리가 발견되었습니다.",
+      exists: "기존 {{rootDir}} 디렉토리가 발견되었습니다.",
       backing_up: "백업을 생성합니다...",
       backedUp: "기존 설치가 백업되었습니다: {{path}}",
       copying: "템플릿 복사 중...",
@@ -11754,6 +11762,7 @@ var ko_default = {
     list: {
       description: "설치된 컴포넌트 목록 표시",
       typeArgument: "표시할 타입: agents, skills, guides, rules 또는 all",
+      providerOption: "표시할 제공자 (auto, claude, codex)",
       scanning: "설치된 컴포넌트 검색 중...",
       empty: "{{type}}이(가) 없습니다.",
       header: "{{type}} ({{count}}개 설치됨)",
@@ -11778,6 +11787,7 @@ var ko_default = {
     doctor: {
       description: "설정 문제 확인 및 수정",
       fixOption: "자동으로 수정 가능한 문제 수정",
+      providerOption: "진단할 제공자 (auto, claude, codex)",
       checking: "진단 검사 실행 중...",
       applyingFixes: "수정 사항 적용 중...",
       fixing: "수정 중: {{name}}...",
@@ -11818,6 +11828,10 @@ var ko_default = {
           pass: "CLAUDE.md 존재함",
           fail: "CLAUDE.md를 찾을 수 없음"
         },
+        entryMd: {
+          pass: "{{entry}} 존재함",
+          fail: "{{entry}}를 찾을 수 없음"
+        },
         rules: {
           pass: "Rules 디렉토리 정상",
           fail: "Rules 디렉토리가 없거나 불완전함"
@@ -12015,6 +12029,341 @@ var $stringify = publicApi.stringify;
 var $visit = visit.visit;
 var $visitAsync = visit.visitAsync;
 
+// 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"
+    ]
+  }
+};
+function getProviderLayout(provider) {
+  return PROVIDER_LAYOUTS[provider];
+}
+function getEntryTemplateName(provider, language) {
+  const layout = getProviderLayout(provider);
+  return `${layout.entryTemplatePrefix}.${language}`;
+}
+function getComponentPath(provider, component) {
+  const layout = getProviderLayout(provider);
+  if (component === "entry-md") {
+    return layout.entryFile;
+  }
+  if (component === "guides") {
+    return "guides";
+  }
+  return `${layout.rootDir}/${component}`;
+}
+function getDefaultProvider() {
+  return "claude";
+}
+
+// src/core/provider.ts
+import { join as join2 } from "node:path";
+
+// src/utils/fs.ts
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+async function fileExists(path) {
+  const fs = await import("node:fs/promises");
+  try {
+    await fs.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureDirectory(path) {
+  const fs = await import("node:fs/promises");
+  await fs.mkdir(path, { recursive: true });
+}
+function shouldSkipEntry(entryName, options) {
+  if (options.exclude?.some((pattern) => matchesPattern(entryName, pattern))) {
+    return true;
+  }
+  if (options.include && !options.include.some((pattern) => matchesPattern(entryName, pattern))) {
+    return true;
+  }
+  return false;
+}
+async function handleSymlink(srcPath, destPath, options, fs) {
+  const destExists = await fileExists(destPath);
+  if (destExists && !options.overwrite) {
+    return;
+  }
+  if (options.preserveSymlinks !== false) {
+    await copyPreservedSymlink(srcPath, destPath, destExists, fs);
+  } else {
+    await copyFollowedSymlink(srcPath, destPath, destExists, options, fs);
+  }
+}
+async function copyPreservedSymlink(srcPath, destPath, destExists, fs) {
+  const linkTarget = await fs.readlink(srcPath);
+  if (destExists) {
+    await fs.unlink(destPath);
+  }
+  await fs.symlink(linkTarget, destPath);
+}
+async function copyFollowedSymlink(srcPath, destPath, destExists, options, fs) {
+  const realPath = await fs.realpath(srcPath);
+  const stat = await fs.stat(realPath);
+  if (stat.isDirectory()) {
+    await copyDirectory(realPath, destPath, options);
+    return;
+  }
+  if (destExists) {
+    await fs.unlink(destPath);
+  }
+  await fs.copyFile(realPath, destPath);
+}
+async function handleFile(srcPath, destPath, options, fs) {
+  const destExists = await fileExists(destPath);
+  if (destExists && !options.overwrite) {
+    return;
+  }
+  await fs.copyFile(srcPath, destPath);
+  if (options.preserveTimestamps) {
+    const stats = await fs.stat(srcPath);
+    await fs.utimes(destPath, stats.atime, stats.mtime);
+  }
+}
+async function copyDirectory(src, dest, options = {}) {
+  const fs = await import("node:fs/promises");
+  const path = await import("node:path");
+  await ensureDirectory(dest);
+  const entries = await fs.readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    if (shouldSkipEntry(entry.name, options)) {
+      continue;
+    }
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isSymbolicLink()) {
+      await handleSymlink(srcPath, destPath, options, fs);
+    } else if (entry.isDirectory()) {
+      await copyDirectory(srcPath, destPath, options);
+    } else if (entry.isFile()) {
+      await handleFile(srcPath, destPath, options, fs);
+    }
+  }
+}
+async function readJsonFile(path) {
+  const fs = await import("node:fs/promises");
+  const content = await fs.readFile(path, "utf-8");
+  return JSON.parse(content);
+}
+async function writeJsonFile(path, data) {
+  const fs = await import("node:fs/promises");
+  const content = JSON.stringify(data, null, 2);
+  await fs.writeFile(path, content, "utf-8");
+}
+async function readTextFile(path) {
+  const fs = await import("node:fs/promises");
+  return fs.readFile(path, "utf-8");
+}
+function getPackageRoot() {
+  const currentFile = fileURLToPath(import.meta.url);
+  const currentDir = dirname(currentFile);
+  return resolve(currentDir, "..", "..");
+}
+function resolveTemplatePath(relativePath) {
+  const packageRoot = getPackageRoot();
+  return join(packageRoot, "templates", relativePath);
+}
+async function listFiles(dir2, options = {}) {
+  const fs = await import("node:fs/promises");
+  const path = await import("node:path");
+  const files = [];
+  const entries = await fs.readdir(dir2, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir2, entry.name);
+    if (entry.isDirectory() && options.recursive) {
+      const subFiles = await listFiles(fullPath, options);
+      files.push(...subFiles);
+    } else if (entry.isFile()) {
+      if (!options.pattern || matchesPattern(entry.name, options.pattern)) {
+        files.push(fullPath);
+      }
+    }
+  }
+  return files;
+}
+function matchesPattern(filename, pattern) {
+  const regexPattern = pattern.replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".");
+  const regex = new RegExp(`^${regexPattern}$`);
+  return regex.test(filename);
+}
+
+// src/core/provider.ts
+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 = [join2(targetDir, "CLAUDE.md"), join2(targetDir, ".claude")];
+  const codexMarkers = [join2(targetDir, "AGENTS.md"), join2(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 = join2(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"
+  };
+}
+
 // src/cli/doctor.ts
 async function pathExists(targetPath) {
   try {
@@ -12107,18 +12456,18 @@ async function countAgents(agentsDir) {
   } catch {}
   return count;
 }
-async function checkClaudeMd(targetDir) {
-  const claudeMdPath = path.join(targetDir, "CLAUDE.md");
-  const exists2 = await pathExists(claudeMdPath);
+async function checkEntryDoc(targetDir, entryFile) {
+  const entryPath = path.join(targetDir, entryFile);
+  const exists2 = await pathExists(entryPath);
   return {
-    name: "CLAUDE.md",
+    name: entryFile,
     status: exists2 ? "pass" : "fail",
-    message: exists2 ? i18n.t("cli.doctor.checks.claudeMd.pass") : i18n.t("cli.doctor.checks.claudeMd.fail"),
+    message: exists2 ? i18n.t("cli.doctor.checks.entryMd.pass", { entry: entryFile }) : i18n.t("cli.doctor.checks.entryMd.fail", { entry: entryFile }),
     fixable: false
   };
 }
-async function checkRules(targetDir) {
-  const rulesDir = path.join(targetDir, ".claude", "rules");
+async function checkRules(targetDir, rootDir = ".claude") {
+  const rulesDir = path.join(targetDir, rootDir, "rules");
   const exists2 = await isDirectory(rulesDir);
   if (!exists2) {
     return {
@@ -12144,8 +12493,8 @@ async function checkRules(targetDir) {
     fixable: false
   };
 }
-async function checkAgents(targetDir) {
-  const agentsDir = path.join(targetDir, ".claude", "agents");
+async function checkAgents(targetDir, rootDir = ".claude") {
+  const agentsDir = path.join(targetDir, rootDir, "agents");
   const exists2 = await isDirectory(agentsDir);
   if (!exists2) {
     return {
@@ -12171,8 +12520,8 @@ async function checkAgents(targetDir) {
     fixable: false
   };
 }
-async function checkSymlinks(targetDir) {
-  const skillsDir = path.join(targetDir, ".claude", "skills");
+async function checkSymlinks(targetDir, rootDir = ".claude") {
+  const skillsDir = path.join(targetDir, rootDir, "skills");
   const brokenSymlinks = [];
   if (await isDirectory(skillsDir)) {
     const skillSymlinks = await findRefsSymlinks(skillsDir);
@@ -12233,8 +12582,8 @@ async function checkIndexFiles(targetDir) {
     fixable: false
   };
 }
-async function checkSkills(targetDir) {
-  const skillsDir = path.join(targetDir, ".claude", "skills");
+async function checkSkills(targetDir, rootDir = ".claude") {
+  const skillsDir = path.join(targetDir, rootDir, "skills");
   const exists2 = await isDirectory(skillsDir);
   if (!exists2) {
     return {
@@ -12287,14 +12636,14 @@ async function checkGuides(targetDir) {
     fixable: false
   };
 }
-async function checkHooks(targetDir) {
-  const hooksDir = path.join(targetDir, ".claude", "hooks");
+async function checkHooks(targetDir, rootDir = ".claude") {
+  const hooksDir = path.join(targetDir, rootDir, "hooks");
   const exists2 = await isDirectory(hooksDir);
   if (!exists2) {
     return {
       name: "Hooks",
       status: "fail",
-      message: ".claude/hooks/ directory not found",
+      message: `${rootDir}/hooks/ directory not found`,
       fixable: true
     };
   }
@@ -12303,7 +12652,7 @@ async function checkHooks(targetDir) {
     return {
       name: "Hooks",
       status: "warn",
-      message: ".claude/hooks/ directory is empty",
+      message: `${rootDir}/hooks/ directory is empty`,
       fixable: false
     };
   }
@@ -12314,14 +12663,14 @@ async function checkHooks(targetDir) {
     fixable: false
   };
 }
-async function checkContexts(targetDir) {
-  const contextsDir = path.join(targetDir, ".claude", "contexts");
+async function checkContexts(targetDir, rootDir = ".claude") {
+  const contextsDir = path.join(targetDir, rootDir, "contexts");
   const exists2 = await isDirectory(contextsDir);
   if (!exists2) {
     return {
       name: "Contexts",
       status: "fail",
-      message: ".claude/contexts/ directory not found",
+      message: `${rootDir}/contexts/ directory not found`,
       fixable: true
     };
   }
@@ -12330,7 +12679,7 @@ async function checkContexts(targetDir) {
     return {
       name: "Contexts",
       status: "warn",
-      message: ".claude/contexts/ directory is empty",
+      message: `${rootDir}/contexts/ directory is empty`,
       fixable: false
     };
   }
@@ -12359,14 +12708,14 @@ async function createMissingDirectory(dirPath) {
     return false;
   }
 }
-async function fixSingleIssue(check, targetDir) {
+async function fixSingleIssue(check, targetDir, rootDir = ".claude") {
   const fixMap = {
-    Rules: () => createMissingDirectory(path.join(targetDir, ".claude", "rules")),
-    Agents: () => createMissingDirectory(path.join(targetDir, ".claude", "agents")),
-    Skills: () => createMissingDirectory(path.join(targetDir, ".claude", "skills")),
+    Rules: () => createMissingDirectory(path.join(targetDir, rootDir, "rules")),
+    Agents: () => createMissingDirectory(path.join(targetDir, rootDir, "agents")),
+    Skills: () => createMissingDirectory(path.join(targetDir, rootDir, "skills")),
     Guides: () => createMissingDirectory(path.join(targetDir, "guides")),
-    Hooks: () => createMissingDirectory(path.join(targetDir, ".claude", "hooks")),
-    Contexts: () => createMissingDirectory(path.join(targetDir, ".claude", "contexts")),
+    Hooks: () => createMissingDirectory(path.join(targetDir, rootDir, "hooks")),
+    Contexts: () => createMissingDirectory(path.join(targetDir, rootDir, "contexts")),
     Symlinks: async () => {
       if (!check.details || check.details.length === 0)
         return false;
@@ -12378,7 +12727,7 @@ async function fixSingleIssue(check, targetDir) {
   const fixer = fixMap[check.name];
   return fixer ? fixer() : false;
 }
-async function fixIssues(checks, targetDir) {
+async function fixIssues(checks, targetDir, rootDir = ".claude") {
   const fixedChecks = [];
   for (const check of checks) {
     if (check.status !== "fail" || !check.fixable) {
@@ -12386,7 +12735,7 @@ async function fixIssues(checks, targetDir) {
       continue;
     }
     console.log(i18n.t("cli.doctor.fixing", { name: check.name }));
-    const fixed = await fixSingleIssue(check, targetDir);
+    const fixed = await fixSingleIssue(check, targetDir, rootDir);
     fixedChecks.push(fixed ? { ...check, fixed: true, message: i18n.t("cli.doctor.fixed", { name: check.name }) } : check);
   }
   return fixedChecks;
@@ -12413,23 +12762,29 @@ 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);
   let checks = await Promise.all([
-    checkClaudeMd(targetDir),
-    checkRules(targetDir),
-    checkAgents(targetDir),
-    checkSkills(targetDir),
-    checkSymlinks(targetDir),
+    checkEntryDoc(targetDir, layout.entryFile),
+    checkRules(targetDir, layout.rootDir),
+    checkAgents(targetDir, layout.rootDir),
+    checkSkills(targetDir, layout.rootDir),
+    checkSymlinks(targetDir, layout.rootDir),
     checkIndexFiles(targetDir),
     checkGuides(targetDir),
-    checkHooks(targetDir),
-    checkContexts(targetDir)
+    checkHooks(targetDir, layout.rootDir),
+    checkContexts(targetDir, layout.rootDir)
   ]);
   if (options.fix) {
     const hasFixableIssues = checks.some((c) => c.status === "fail" && c.fixable);
     if (hasFixableIssues) {
       console.log(i18n.t("cli.doctor.applyingFixes"));
       console.log("");
-      checks = await fixIssues(checks, targetDir);
+      checks = await fixIssues(checks, targetDir, layout.rootDir);
       console.log("");
     }
   }
@@ -12471,144 +12826,11 @@ async function doctorCommand(options = {}) {
 }
 
 // src/cli/init.ts
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
 
 // src/core/installer.ts
 import { copyFile as fsCopyFile, rename } from "node:fs/promises";
-import { basename, join as join3 } from "node:path";
-
-// src/utils/fs.ts
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-async function fileExists(path2) {
-  const fs2 = await import("node:fs/promises");
-  try {
-    await fs2.access(path2);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function ensureDirectory(path2) {
-  const fs2 = await import("node:fs/promises");
-  await fs2.mkdir(path2, { recursive: true });
-}
-function shouldSkipEntry(entryName, options) {
-  if (options.exclude?.some((pattern) => matchesPattern(entryName, pattern))) {
-    return true;
-  }
-  if (options.include && !options.include.some((pattern) => matchesPattern(entryName, pattern))) {
-    return true;
-  }
-  return false;
-}
-async function handleSymlink(srcPath, destPath, options, fs2) {
-  const destExists = await fileExists(destPath);
-  if (destExists && !options.overwrite) {
-    return;
-  }
-  if (options.preserveSymlinks !== false) {
-    await copyPreservedSymlink(srcPath, destPath, destExists, fs2);
-  } else {
-    await copyFollowedSymlink(srcPath, destPath, destExists, options, fs2);
-  }
-}
-async function copyPreservedSymlink(srcPath, destPath, destExists, fs2) {
-  const linkTarget = await fs2.readlink(srcPath);
-  if (destExists) {
-    await fs2.unlink(destPath);
-  }
-  await fs2.symlink(linkTarget, destPath);
-}
-async function copyFollowedSymlink(srcPath, destPath, destExists, options, fs2) {
-  const realPath = await fs2.realpath(srcPath);
-  const stat = await fs2.stat(realPath);
-  if (stat.isDirectory()) {
-    await copyDirectory(realPath, destPath, options);
-    return;
-  }
-  if (destExists) {
-    await fs2.unlink(destPath);
-  }
-  await fs2.copyFile(realPath, destPath);
-}
-async function handleFile(srcPath, destPath, options, fs2) {
-  const destExists = await fileExists(destPath);
-  if (destExists && !options.overwrite) {
-    return;
-  }
-  await fs2.copyFile(srcPath, destPath);
-  if (options.preserveTimestamps) {
-    const stats = await fs2.stat(srcPath);
-    await fs2.utimes(destPath, stats.atime, stats.mtime);
-  }
-}
-async function copyDirectory(src, dest, options = {}) {
-  const fs2 = await import("node:fs/promises");
-  const path2 = await import("node:path");
-  await ensureDirectory(dest);
-  const entries = await fs2.readdir(src, { withFileTypes: true });
-  for (const entry of entries) {
-    if (shouldSkipEntry(entry.name, options)) {
-      continue;
-    }
-    const srcPath = path2.join(src, entry.name);
-    const destPath = path2.join(dest, entry.name);
-    if (entry.isSymbolicLink()) {
-      await handleSymlink(srcPath, destPath, options, fs2);
-    } else if (entry.isDirectory()) {
-      await copyDirectory(srcPath, destPath, options);
-    } else if (entry.isFile()) {
-      await handleFile(srcPath, destPath, options, fs2);
-    }
-  }
-}
-async function readJsonFile(path2) {
-  const fs2 = await import("node:fs/promises");
-  const content = await fs2.readFile(path2, "utf-8");
-  return JSON.parse(content);
-}
-async function writeJsonFile(path2, data) {
-  const fs2 = await import("node:fs/promises");
-  const content = JSON.stringify(data, null, 2);
-  await fs2.writeFile(path2, content, "utf-8");
-}
-async function readTextFile(path2) {
-  const fs2 = await import("node:fs/promises");
-  return fs2.readFile(path2, "utf-8");
-}
-function getPackageRoot() {
-  const currentFile = fileURLToPath(import.meta.url);
-  const currentDir = dirname(currentFile);
-  return resolve(currentDir, "..", "..");
-}
-function resolveTemplatePath(relativePath) {
-  const packageRoot = getPackageRoot();
-  return join(packageRoot, "templates", relativePath);
-}
-async function listFiles(dir2, options = {}) {
-  const fs2 = await import("node:fs/promises");
-  const path2 = await import("node:path");
-  const files = [];
-  const entries = await fs2.readdir(dir2, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path2.join(dir2, entry.name);
-    if (entry.isDirectory() && options.recursive) {
-      const subFiles = await listFiles(fullPath, options);
-      files.push(...subFiles);
-    } else if (entry.isFile()) {
-      if (!options.pattern || matchesPattern(entry.name, options.pattern)) {
-        files.push(fullPath);
-      }
-    }
-  }
-  return files;
-}
-function matchesPattern(filename, pattern) {
-  const regexPattern = pattern.replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".");
-  const regex = new RegExp(`^${regexPattern}$`);
-  return regex.test(filename);
-}
+import { basename, join as join4 } from "node:path";
 
 // src/utils/logger.ts
 var currentOptions = {
@@ -12659,7 +12881,7 @@ var MESSAGES = {
     "install.start": "Initializing oh-my-customcode...",
     "install.success": "Successfully initialized!",
     "install.failed": "Installation failed: {{error}}",
-    "install.exists": "Existing .claude/ directory found",
+    "install.exists": "Existing {{rootDir}} directory found",
     "install.backup": "Backed up existing files to: {{path}}",
     "install.directories_created": "Directory structure created",
     "install.component_skipped": "Skipped {{component}} (already exists)",
@@ -12667,6 +12889,9 @@ var MESSAGES = {
     "install.template_not_found": "Template not found for {{component}}: {{path}}",
     "install.claude_md_installed": "CLAUDE.md installed ({{language}})",
     "install.claude_md_not_found": "CLAUDE.md template not found for {{language}}",
+    "install.entry_md_installed": "{{entry}} installed ({{language}})",
+    "install.entry_md_not_found": "{{entry}} template not found for {{language}}",
+    "install.entry_md_skipped": "{{entry}} skipped ({{reason}})",
     "update.start": "Checking for updates...",
     "update.success": "Updated from {{from}} to {{to}}",
     "update.failed": "Update failed: {{error}}",
@@ -12687,7 +12912,7 @@ var MESSAGES = {
     "install.start": "oh-my-customcode 초기화 중...",
     "install.success": "초기화 완료!",
     "install.failed": "설치 실패: {{error}}",
-    "install.exists": "기존 .claude/ 디렉토리 발견",
+    "install.exists": "기존 {{rootDir}} 디렉토리 발견",
     "install.backup": "기존 파일 백업 완료: {{path}}",
     "install.directories_created": "디렉토리 구조 생성 완료",
     "install.component_skipped": "{{component}} 건너뜀 (이미 존재)",
@@ -12695,6 +12920,9 @@ var MESSAGES = {
     "install.template_not_found": "{{component}} 템플릿 없음: {{path}}",
     "install.claude_md_installed": "CLAUDE.md 설치 완료 ({{language}})",
     "install.claude_md_not_found": "{{language}}용 CLAUDE.md 템플릿 없음",
+    "install.entry_md_installed": "{{entry}} 설치 완료 ({{language}})",
+    "install.entry_md_not_found": "{{language}}용 {{entry}} 템플릿 없음",
+    "install.entry_md_skipped": "{{entry}} 건너뜀 ({{reason}})",
     "update.start": "업데이트 확인 중...",
     "update.success": "{{from}}에서 {{to}}로 업데이트 완료",
     "update.failed": "업데이트 실패: {{error}}",
@@ -12794,7 +13022,7 @@ function success(messageKey, params) {
 }
 
 // src/core/config.ts
-import { join as join2 } from "node:path";
+import { join as join3 } from "node:path";
 var CONFIG_FILE = ".omcustomrc.json";
 var CURRENT_CONFIG_VERSION = 1;
 function getDefaultConfig() {
@@ -12827,7 +13055,7 @@ function getDefaultPreferences() {
   };
 }
 function getConfigPath(targetDir) {
-  return join2(targetDir, CONFIG_FILE);
+  return join3(targetDir, CONFIG_FILE);
 }
 async function loadConfig(targetDir) {
   const configPath = getConfigPath(targetDir);
@@ -12888,18 +13116,10 @@ function migrateConfig(config) {
 }
 
 // src/core/installer.ts
-var COMPONENT_PATHS = {
-  "claude-md": "",
-  rules: ".claude/rules",
-  agents: ".claude/agents",
-  skills: ".claude/skills",
-  guides: "guides",
-  hooks: ".claude/hooks",
-  contexts: ".claude/contexts"
-};
+var DEFAULT_LANGUAGE2 = "en";
 function getTemplateDir() {
   const packageRoot = getPackageRoot();
-  return join3(packageRoot, "templates");
+  return join4(packageRoot, "templates");
 }
 function createInstallResult(targetDir) {
   return {
@@ -12917,21 +13137,22 @@ async function ensureTargetDirectory(targetDir) {
     await ensureDirectory(targetDir);
   }
 }
-async function handleBackup(targetDir, shouldBackup, result) {
+async function handleBackup(targetDir, provider, shouldBackup, result) {
   if (!shouldBackup)
     return;
-  const backupPaths = await backupExistingInstallation(targetDir);
+  const backupPaths = await backupExistingInstallation(targetDir, provider);
   result.backedUpPaths.push(...backupPaths);
   if (backupPaths.length > 0) {
     info("install.backup", { path: backupPaths[0] });
   }
 }
-async function checkAndWarnExisting(targetDir, force, backup, result) {
+async function checkAndWarnExisting(targetDir, provider, force, backup, result) {
   if (force || backup)
     return;
-  const existingPaths = await checkExistingPaths(targetDir);
+  const existingPaths = await checkExistingPaths(targetDir, provider);
   if (existingPaths.length > 0) {
-    warn("install.exists");
+    const layout = getProviderLayout(provider);
+    warn("install.exists", { rootDir: layout.rootDir });
     result.warnings.push(`Existing files found: ${existingPaths.join(", ")}. Use --force to overwrite or --backup to backup first.`);
   }
 }
@@ -12941,15 +13162,15 @@ async function verifyTemplateDirectory() {
     throw new Error(`Template directory not found: ${templateDir}`);
   }
 }
-async function installAllComponents(targetDir, options, result) {
+async function installAllComponents(targetDir, provider, options, result) {
   const components = options.components || getAllComponents();
   for (const component of components) {
-    await installSingleComponent(targetDir, component, options, result);
+    await installSingleComponent(targetDir, provider, component, options, result);
   }
 }
-async function installSingleComponent(targetDir, component, options, result) {
+async function installSingleComponent(targetDir, provider, component, options, result) {
   try {
-    const installed = await installComponent(targetDir, component, options);
+    const installed = await installComponent(targetDir, provider, component, options);
     if (installed) {
       result.installedComponents.push(component);
     } else {
@@ -12960,34 +13181,36 @@ async function installSingleComponent(targetDir, component, options, result) {
     result.warnings.push(`Failed to install ${component}: ${message}`);
   }
 }
-async function installClaudeMdWithTracking(targetDir, options, result) {
-  const language = options.language || "en";
+async function installEntryDocWithTracking(targetDir, provider, options, result) {
+  const language = options.language ?? DEFAULT_LANGUAGE2;
   const overwrite = !!(options.force || options.backup);
-  const installed = await installClaudeMd(targetDir, language, overwrite);
+  const installed = await installEntryDoc(targetDir, provider, language, overwrite);
   if (installed) {
-    result.installedComponents.push("claude-md");
+    result.installedComponents.push("entry-md");
   } else {
-    result.skippedComponents.push("claude-md");
+    result.skippedComponents.push("entry-md");
   }
 }
-async function updateInstallConfig(targetDir, options, installedComponents) {
+async function updateInstallConfig(targetDir, provider, options, installedComponents) {
   const config = await loadConfig(targetDir);
-  config.language = options.language || "en";
+  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, !!options.backup, result);
-    await checkAndWarnExisting(options.targetDir, !!options.force, !!options.backup, result);
+    await handleBackup(options.targetDir, provider, !!options.backup, result);
+    await checkAndWarnExisting(options.targetDir, provider, !!options.force, !!options.backup, result);
     await verifyTemplateDirectory();
-    await installAllComponents(options.targetDir, options, result);
-    await installClaudeMdWithTracking(options.targetDir, options, result);
-    await updateInstallConfig(options.targetDir, options, result.installedComponents);
+    await installAllComponents(options.targetDir, provider, options, result);
+    await installEntryDocWithTracking(options.targetDir, provider, options, result);
+    await updateInstallConfig(options.targetDir, provider, options, result.installedComponents);
     result.success = true;
     success("install.success");
   } catch (err) {
@@ -13000,12 +13223,15 @@ async function install(options) {
 function getAllComponents() {
   return ["rules", "agents", "skills", "guides", "hooks", "contexts"];
 }
-async function installComponent(targetDir, component, options) {
-  const templatePath = COMPONENT_PATHS[component];
+async function installComponent(targetDir, provider, component, options) {
+  if (component === "entry-md") {
+    return false;
+  }
+  const templatePath = getComponentPath(provider, component);
   if (!templatePath) {
     return false;
   }
-  const destPath = join3(targetDir, templatePath);
+  const destPath = join4(targetDir, templatePath);
   const destExists = await fileExists(destPath);
   if (destExists && !options.force && !options.backup) {
     debug("install.component_skipped", { component });
@@ -13024,51 +13250,54 @@ async function installComponent(targetDir, component, options) {
   debug("install.component_installed", { component });
   return true;
 }
-async function installClaudeMd(targetDir, language, overwrite = false) {
-  const templateFile = `CLAUDE.md.${language}`;
+async function installEntryDoc(targetDir, provider, language, overwrite = false) {
+  const layout = getProviderLayout(provider);
+  const templateFile = getEntryTemplateName(provider, language);
   const srcPath = resolveTemplatePath(templateFile);
-  const destPath = join3(targetDir, "CLAUDE.md");
+  const destPath = join4(targetDir, layout.entryFile);
   if (!await fileExists(srcPath)) {
-    warn("install.claude_md_not_found", { language, path: srcPath });
+    warn("install.entry_md_not_found", { language, path: srcPath, entry: layout.entryFile });
     return false;
   }
   const destExists = await fileExists(destPath);
   if (destExists && !overwrite) {
-    debug("install.claude_md_skipped", { reason: "exists", language });
+    debug("install.entry_md_skipped", { reason: "exists", language, entry: layout.entryFile });
     return false;
   }
   await fsCopyFile(srcPath, destPath);
-  debug("install.claude_md_installed", { language });
+  debug("install.entry_md_installed", { language, entry: layout.entryFile });
   return true;
 }
 async function backupExisting(sourcePath, backupDir) {
   const name = basename(sourcePath);
-  const backupPath = join3(backupDir, name);
+  const backupPath = join4(backupDir, name);
   await rename(sourcePath, backupPath);
   return backupPath;
 }
-async function checkExistingPaths(targetDir) {
-  const pathsToCheck = ["CLAUDE.md", ".claude", "guides"];
+async function checkExistingPaths(targetDir, provider) {
+  const layout = getProviderLayout(provider);
+  const pathsToCheck = [layout.entryFile, layout.rootDir, "guides"];
   const existingPaths = [];
   for (const relativePath of pathsToCheck) {
-    const fullPath = join3(targetDir, relativePath);
+    const fullPath = join4(targetDir, relativePath);
     if (await fileExists(fullPath)) {
       existingPaths.push(relativePath);
     }
   }
   return existingPaths;
 }
-async function backupExistingInstallation(targetDir) {
-  const existingPaths = await checkExistingPaths(targetDir);
+async function backupExistingInstallation(targetDir, provider) {
+  const layout = getProviderLayout(provider);
+  const existingPaths = await checkExistingPaths(targetDir, provider);
   if (existingPaths.length === 0) {
     return [];
   }
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-  const backupDir = join3(targetDir, `.claude-backup-${timestamp}`);
+  const backupDir = join4(targetDir, `${layout.backupDirPrefix}${timestamp}`);
   await ensureDirectory(backupDir);
   const backedUpPaths = [];
   for (const relativePath of existingPaths) {
-    const fullPath = join3(targetDir, relativePath);
+    const fullPath = join4(targetDir, relativePath);
     try {
       const backupPath = await backupExisting(fullPath, backupDir);
       backedUpPaths.push(backupPath);
@@ -13082,22 +13311,25 @@ async function backupExistingInstallation(targetDir) {
 }
 
 // src/cli/init.ts
-async function checkExistingInstallation(targetDir) {
-  const claudeDir = join4(targetDir, ".claude");
-  return fileExists(claudeDir);
+async function checkExistingInstallation(targetDir, provider) {
+  const layout = getProviderLayout(provider);
+  const rootDir = join5(targetDir, layout.rootDir);
+  return fileExists(rootDir);
 }
-var CLAUDE_SUBDIR_COMPONENTS = new Set(["rules", "hooks", "contexts", "agents", "skills"]);
-function componentToPath(targetDir, component) {
-  if (component === "claude-md") {
-    return join4(targetDir, "CLAUDE.md");
+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 join5(targetDir, layout.entryFile);
   }
-  if (CLAUDE_SUBDIR_COMPONENTS.has(component)) {
-    return join4(targetDir, ".claude", component);
+  if (PROVIDER_SUBDIR_COMPONENTS.has(component)) {
+    const layout = getProviderLayout(provider);
+    return join5(targetDir, layout.rootDir, component);
   }
-  return join4(targetDir, component);
+  return join5(targetDir, component);
 }
-function buildInstalledPaths(targetDir, components) {
-  return components.map((component) => componentToPath(targetDir, component));
+function buildInstalledPaths(targetDir, provider, components) {
+  return components.map((component) => componentToPath(targetDir, provider, component));
 }
 function logItems(items, formatter) {
   for (const item of items) {
@@ -13122,10 +13354,6 @@ function createFailureResult(errorMessage) {
     errors: [errorMessage]
   };
 }
-function notifyExistingInstallation() {
-  console.log(i18n.t("cli.init.exists"));
-  console.log(i18n.t("cli.init.backing_up"));
-}
 function logInstallResultInfo(result) {
   logItems(result.backedUpPaths, (path2) => console.log(i18n.t("cli.init.backedUp", { path: path2 })));
   logItems(result.warnings, (warning) => console.warn(`Warning: ${warning}`));
@@ -13134,21 +13362,26 @@ async function initCommand(options) {
   const targetDir = process.cwd();
   console.log(i18n.t("cli.init.start"));
   try {
-    const exists2 = await checkExistingInstallation(targetDir);
+    const detection = await detectProvider({ targetDir, override: options.provider });
+    const provider = detection.provider;
+    const layout = getProviderLayout(provider);
+    const exists2 = await checkExistingInstallation(targetDir, provider);
     if (exists2) {
-      notifyExistingInstallation();
+      console.log(i18n.t("cli.init.exists", { rootDir: layout.rootDir }));
+      console.log(i18n.t("cli.init.backing_up"));
     }
     console.log(i18n.t("cli.init.copying"));
     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, installResult.installedComponents);
+    const installedPaths = buildInstalledPaths(targetDir, provider, installResult.installedComponents);
     logInstallResultInfo(installResult);
     logSuccessDetails(installedPaths, installResult.skippedComponents);
     return {
@@ -13164,7 +13397,7 @@ async function initCommand(options) {
 }
 
 // src/cli/list.ts
-import { basename as basename2, dirname as dirname2, join as join5, relative } from "node:path";
+import { basename as basename2, dirname as dirname2, join as join6, relative } from "node:path";
 var ALLOWED_TOP_LEVEL_KEYS = new Set(["name", "type", "description", "version", "category"]);
 function parseKeyValue(line) {
   const colonIndex = line.indexOf(":");
@@ -13227,13 +13460,13 @@ function extractAgentTypeFromFilename(filename) {
   const prefix = name.split("-")[0];
   return prefixMap[prefix] || "unknown";
 }
-function extractSkillCategoryFromPath(skillPath, baseDir) {
-  const relativePath = relative(join5(baseDir, ".claude", "skills"), skillPath);
+function extractSkillCategoryFromPath(skillPath, baseDir, rootDir) {
+  const relativePath = relative(join6(baseDir, rootDir, "skills"), skillPath);
   const parts = relativePath.split("/").filter(Boolean);
   return parts[0] || "unknown";
 }
 function extractGuideCategoryFromPath(guidePath, baseDir) {
-  const relativePath = relative(join5(baseDir, "guides"), guidePath);
+  const relativePath = relative(join6(baseDir, "guides"), guidePath);
   const parts = relativePath.split("/").filter(Boolean);
   return parts[0] || "unknown";
 }
@@ -13326,8 +13559,8 @@ async function tryExtractMarkdownDescription(mdPath, options = {}) {
     return;
   }
 }
-async function getAgents(targetDir) {
-  const agentsDir = join5(targetDir, ".claude", "agents");
+async function getAgents(targetDir, rootDir = ".claude") {
+  const agentsDir = join6(targetDir, rootDir, "agents");
   if (!await fileExists(agentsDir))
     return [];
   try {
@@ -13349,20 +13582,20 @@ async function getAgents(targetDir) {
     return [];
   }
 }
-async function getSkills(targetDir) {
-  const skillsDir = join5(targetDir, ".claude", "skills");
+async function getSkills(targetDir, rootDir = ".claude") {
+  const skillsDir = join6(targetDir, rootDir, "skills");
   if (!await fileExists(skillsDir))
     return [];
   try {
     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 = join5(skillDir, "index.yaml");
+      const indexYamlPath = join6(skillDir, "index.yaml");
       const { description, version } = await tryReadIndexYamlMetadata(indexYamlPath);
       return {
         name: basename2(skillDir),
         type: "skill",
-        category: extractSkillCategoryFromPath(skillDir, targetDir),
+        category: extractSkillCategoryFromPath(skillDir, targetDir, rootDir),
         path: relative(targetDir, skillDir),
         description,
         version
@@ -13374,7 +13607,7 @@ async function getSkills(targetDir) {
   }
 }
 async function getGuides(targetDir) {
-  const guidesDir = join5(targetDir, "guides");
+  const guidesDir = join6(targetDir, "guides");
   if (!await fileExists(guidesDir))
     return [];
   try {
@@ -13395,8 +13628,8 @@ async function getGuides(targetDir) {
   }
 }
 var RULE_PRIORITY_ORDER = { MUST: 0, SHOULD: 1, MAY: 2 };
-async function getRules(targetDir) {
-  const rulesDir = join5(targetDir, ".claude", "rules");
+async function getRules(targetDir, rootDir = ".claude") {
+  const rulesDir = join6(targetDir, rootDir, "rules");
   if (!await fileExists(rulesDir))
     return [];
   try {
@@ -13460,8 +13693,8 @@ ${type} (${components.length}):`);
 function formatAsJson(components) {
   console.log(JSON.stringify(components, null, 2));
 }
-async function getHooks(targetDir) {
-  const hooksDir = join5(targetDir, ".claude", "hooks");
+async function getHooks(targetDir, rootDir = ".claude") {
+  const hooksDir = join6(targetDir, rootDir, "hooks");
   if (!await fileExists(hooksDir))
     return [];
   try {
@@ -13478,8 +13711,8 @@ async function getHooks(targetDir) {
     return [];
   }
 }
-async function getContexts(targetDir) {
-  const contextsDir = join5(targetDir, ".claude", "contexts");
+async function getContexts(targetDir, rootDir = ".claude") {
+  const contextsDir = join6(targetDir, rootDir, "contexts");
   if (!await fileExists(contextsDir))
     return [];
   try {
@@ -13504,7 +13737,7 @@ async function getContexts(targetDir) {
 var COMPONENT_GETTERS = {
   agents: getAgents,
   skills: getSkills,
-  guides: getGuides,
+  guides: async (dir2) => getGuides(dir2),
   rules: getRules,
   hooks: getHooks,
   contexts: getContexts
@@ -13518,14 +13751,14 @@ function displayComponents(components, type, format) {
     formatAsTable(components, type);
   }
 }
-async function handleListAll(targetDir, format) {
+async function handleListAll(targetDir, rootDir, format) {
   const [agents, skills, guides, rules, hooks, contexts] = await Promise.all([
-    getAgents(targetDir),
-    getSkills(targetDir),
+    getAgents(targetDir, rootDir),
+    getSkills(targetDir, rootDir),
     getGuides(targetDir),
-    getRules(targetDir),
-    getHooks(targetDir),
-    getContexts(targetDir)
+    getRules(targetDir, rootDir),
+    getHooks(targetDir, rootDir),
+    getContexts(targetDir, rootDir)
   ]);
   if (format !== "json") {
     displayComponents(agents, "agents", format);
@@ -13542,7 +13775,13 @@ async function listCommand(type = "all", options = {}) {
   const format = options.format || "table";
   console.log(i18n.t("cli.list.scanning"));
   try {
-    const components = type === "all" ? await handleListAll(targetDir, format) : await COMPONENT_GETTERS[type](targetDir);
+    const detection = await detectProvider({
+      targetDir,
+      override: options.provider,
+      preferProject: true
+    });
+    const layout = getProviderLayout(detection.provider);
+    const components = type === "all" ? await handleListAll(targetDir, layout.rootDir, format) : await COMPONENT_GETTERS[type](targetDir, layout.rootDir);
     if (type === "all" && format === "json") {
       formatAsJson(components);
     } else if (type !== "all") {
@@ -13632,16 +13871,20 @@ var packageJson = require2("../../package.json");
 function createProgram() {
   const program2 = new Command;
   program2.name("omcustom").description(i18n.t("cli.description")).version(packageJson.version, "-v, --version", i18n.t("cli.versionOption"));
-  program2.command("init").description(i18n.t("cli.init.description")).option("-l, --lang <language>", i18n.t("cli.init.langOption"), "en").action(async (options) => {
+  program2.command("init").description(i18n.t("cli.init.description")).option("-l, --lang <language>", i18n.t("cli.init.langOption"), "en").option("-p, --provider <provider>", i18n.t("cli.init.providerOption"), "auto").action(async (options) => {
     await initCommand(options);
   });
   program2.command("update").description(i18n.t("cli.update.description")).action(async () => {
     await updateCommand();
   });
-  program2.command("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 });
+  program2.command("list").description(i18n.t("cli.list.description")).argument("[type]", i18n.t("cli.list.typeArgument"), "all").option("-f, --format <format>", "Output format: table, json, or simple", "table").option("--verbose", "Show detailed information").option("-p, --provider <provider>", i18n.t("cli.list.providerOption"), "auto").action(async (type, options) => {
+    await listCommand(type, {
+      format: options.format,
+      verbose: options.verbose,
+      provider: options.provider
+    });
   });
-  program2.command("doctor").description(i18n.t("cli.doctor.description")).option("--fix", i18n.t("cli.doctor.fixOption")).action(async (options) => {
+  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);
   });
   return program2;