coding-tool-x 3.5.6 → 3.5.8

package/src/server/services/commands-service.js

@@ -8,7 +8,7 @@
 const fs = require('fs');
 const path = require('path');
 const { RepoScannerBase } = require('./repo-scanner-base');
-const { NATIVE_PATHS } = require('../../config/paths');
+const { NATIVE_PATHS, PATHS } = require('../../config/paths');
 const {
   parseCommandContent,
   parseFrontmatter
@@ -17,18 +17,21 @@ const {
 // 默认仓库源
 const DEFAULT_REPOS = [];
 const SUPPORTED_PLATFORMS = ['claude', 'opencode'];
-const OPENCODE_CONFIG_DIR = NATIVE_PATHS.opencode.config;
-const CLAUDE_COMMANDS_DIR = path.join(path.dirname(NATIVE_PATHS.claude.settings), 'commands');
+const CLAUDE_COMMANDS_DIR = NATIVE_PATHS.claude.commands;
+const OPENCODE_COMMANDS_DIR = NATIVE_PATHS.opencode.commands;
+const OPENCODE_LEGACY_COMMANDS_DIR = NATIVE_PATHS.opencode.commandsLegacy;
 
 const PLATFORM_CONFIG = {
   claude: {
     userCommandsDir: CLAUDE_COMMANDS_DIR,
+    storageDir: PATHS.localCommands.claude,
     projectCommandsDir: (projectPath) => path.join(projectPath, '.claude', 'commands'),
     repoType: 'commands'
   },
   opencode: {
-    userCommandsDir: path.join(OPENCODE_CONFIG_DIR, 'commands'),
-    legacyUserCommandsDir: path.join(OPENCODE_CONFIG_DIR, 'command'),
+    userCommandsDir: OPENCODE_COMMANDS_DIR,
+    storageDir: PATHS.localCommands.opencode,
+    legacyUserCommandsDir: OPENCODE_LEGACY_COMMANDS_DIR,
     projectCommandsDir: (projectPath) => {
       const modern = path.join(projectPath, '.opencode', 'commands');
       const legacy = path.join(projectPath, '.opencode', 'command');
@@ -54,6 +57,25 @@ function ensureDir(dirPath) {
   }
 }
 
+function normalizeCommandRelativePath(relativePath, errorLabel = '命令路径') {
+  const raw = String(relativePath || '').replace(/\\/g, '/').trim();
+  if (!raw || raw.includes('\0')) {
+    throw new Error(`${errorLabel}不合法`);
+  }
+
+  const normalized = path.posix.normalize(raw).replace(/^(\.\/)+/, '');
+  if (!normalized ||
+      normalized === '.' ||
+      normalized === '..' ||
+      normalized.startsWith('../') ||
+      normalized.includes('/../') ||
+      path.posix.isAbsolute(normalized)) {
+    throw new Error(`${errorLabel}不合法`);
+  }
+
+  return normalized;
+}
+
 /**
  * 生成 frontmatter 字符串（用于命令创建/更新）
  */
@@ -89,7 +111,7 @@ function generateCommandFrontmatter(data) {
 /**
  * 递归扫描目录获取命令文件
  */
-function scanCommandsDir(dir, basePath, scope) {
+function scanCommandsDir(dir, basePath, scope, options = {}) {
   const commands = [];
 
   if (!fs.existsSync(dir)) {
@@ -104,7 +126,7 @@ function scanCommandsDir(dir, basePath, scope) {
 
       if (entry.isDirectory() && !entry.name.startsWith('.')) {
         // 递归扫描子目录
-        const subCommands = scanCommandsDir(fullPath, basePath, scope);
+        const subCommands = scanCommandsDir(fullPath, basePath, scope, options);
         commands.push(...subCommands);
       } else if (entry.isFile() && entry.name.endsWith('.md')) {
         // 解析命令文件
@@ -113,11 +135,10 @@ function scanCommandsDir(dir, basePath, scope) {
           const { frontmatter, body } = parseFrontmatter(content);
 
           // 计算相对路径和命令名
-          const relativePath = path.relative(basePath, fullPath);
+          const relativePath = normalizeCommandRelativePath(path.relative(basePath, fullPath));
           const commandName = entry.name.replace(/\.md$/, '');
           const namespace = path.dirname(relativePath);
-
-          commands.push({
+          const command = {
             name: commandName,
             namespace: namespace === '.' ? null : namespace,
             scope,
@@ -132,7 +153,15 @@ function scanCommandsDir(dir, basePath, scope) {
             body,
             fullContent: content,
             updatedAt: fs.statSync(fullPath).mtime.getTime()
-          });
+          };
+          const decoratedCommand = typeof options.decorate === 'function'
+            ? {
+                ...command,
+                ...options.decorate(command)
+              }
+            : command;
+
+          commands.push(decoratedCommand);
         } catch (err) {
           console.warn(`[CommandsService] Failed to parse ${fullPath}:`, err.message);
         }
@@ -240,6 +269,7 @@ class CommandsService {
     const config = PLATFORM_CONFIG[this.platform];
 
     this.userCommandsDir = config.userCommandsDir;
+    this.storageDir = config.storageDir;
     if (this.platform === 'opencode') {
       const legacyUserDir = config.legacyUserCommandsDir;
       if (legacyUserDir && fs.existsSync(legacyUserDir) && !fs.existsSync(this.userCommandsDir)) {
@@ -250,6 +280,7 @@ class CommandsService {
     this.projectCommandsDir = config.projectCommandsDir;
     this.repoScanner = new CommandsRepoScanner(this.platform, this.userCommandsDir);
     ensureDir(this.userCommandsDir);
+    ensureDir(this.storageDir);
   }
 
   getProjectCommandsDir(projectPath) {
@@ -261,28 +292,165 @@ class CommandsService {
    * 获取所有命令列表
    * @param {string} projectPath - 项目路径（可选，用于获取项目级命令）
    */
-  listCommands(projectPath = null) {
+  getManagedCommandPath(relativePath) {
+    return path.join(this.storageDir, normalizeCommandRelativePath(relativePath));
+  }
+
+  isInstalledCommand(relativePath) {
+    return fs.existsSync(path.join(this.userCommandsDir, normalizeCommandRelativePath(relativePath)));
+  }
+
+  buildCommandContent({ description, allowedTools, argumentHint, agent, model, subtask, body }) {
+    const frontmatterData = {};
+    if (description) frontmatterData.description = description;
+    if (this.platform !== 'opencode') {
+      if (allowedTools) frontmatterData['allowed-tools'] = allowedTools;
+      if (argumentHint) frontmatterData['argument-hint'] = argumentHint;
+    }
+    if (agent) frontmatterData.agent = agent;
+    if (model) frontmatterData.model = model;
+    if (typeof subtask === 'boolean') frontmatterData.subtask = subtask;
+
+    let content = '';
+    if (Object.keys(frontmatterData).length > 0) {
+      content = generateCommandFrontmatter(frontmatterData) + '\n\n';
+    }
+    content += body || '';
+    return content;
+  }
+
+  copyFileRecursive(sourcePath, targetPath) {
+    ensureDir(path.dirname(targetPath));
+    fs.copyFileSync(sourcePath, targetPath);
+  }
+
+  ensureManagedCommandCopy(relativePath, sourcePath, options = {}) {
+    const overwrite = options.overwrite === true;
+    const normalizedPath = normalizeCommandRelativePath(relativePath);
+    if (!sourcePath || !fs.existsSync(sourcePath)) {
+      return false;
+    }
+
+    const managedPath = this.getManagedCommandPath(normalizedPath);
+    if (fs.existsSync(managedPath) && !overwrite) {
+      return false;
+    }
+
+    this.copyFileRecursive(sourcePath, managedPath);
+    return true;
+  }
+
+  removeEmptyCommandDirs(baseDir, relativePath) {
+    const normalizedPath = normalizeCommandRelativePath(relativePath);
+    let currentDir = path.dirname(path.join(baseDir, normalizedPath));
+    const resolvedBaseDir = path.resolve(baseDir);
+
+    while (currentDir && currentDir !== resolvedBaseDir && currentDir.startsWith(`${resolvedBaseDir}${path.sep}`)) {
+      try {
+        if (fs.existsSync(currentDir) && fs.readdirSync(currentDir).length === 0) {
+          fs.rmdirSync(currentDir);
+          currentDir = path.dirname(currentDir);
+          continue;
+        }
+      } catch {
+        // ignore cleanup failures
+      }
+      break;
+    }
+  }
+
+  mergeInstalledUserCommands(commands, options = {}) {
+    const syncManagedLocalCommands = options.syncManagedLocalCommands === true;
+    const installedCommands = scanCommandsDir(this.userCommandsDir, this.userCommandsDir, 'user', {
+      decorate: () => ({
+        installed: true,
+        isManagedLocal: false,
+        source: 'native-installed'
+      })
+    });
+
+    for (const installedCommand of installedCommands) {
+      const existing = commands.find(command =>
+        command.scope === 'user' &&
+        command.path.toLowerCase() === installedCommand.path.toLowerCase()
+      );
+      const managedPath = this.getManagedCommandPath(installedCommand.path);
+
+      if (existing) {
+        if (syncManagedLocalCommands && fs.existsSync(managedPath)) {
+          this.ensureManagedCommandCopy(installedCommand.path, installedCommand.fullPath, { overwrite: true });
+        }
+        existing.installed = true;
+        if (!existing.description && installedCommand.description) existing.description = installedCommand.description;
+        if (!existing.body && installedCommand.body) existing.body = installedCommand.body;
+        if (!existing.fullContent && installedCommand.fullContent) existing.fullContent = installedCommand.fullContent;
+        continue;
+      }
+
+      this.ensureManagedCommandCopy(installedCommand.path, installedCommand.fullPath, {
+        overwrite: syncManagedLocalCommands
+      });
+      commands.push(installedCommand);
+    }
+  }
+
+  mergeLocalUserCommands(commands) {
+    if (!fs.existsSync(this.storageDir)) return;
+
+    const localCommands = scanCommandsDir(this.storageDir, this.storageDir, 'user', {
+      decorate: (command) => ({
+        installed: this.isInstalledCommand(command.path),
+        isManagedLocal: true,
+        source: 'local'
+      })
+    });
+
+    for (const localCommand of localCommands) {
+      const existing = commands.find(command =>
+        command.scope === 'user' &&
+        command.path.toLowerCase() === localCommand.path.toLowerCase()
+      );
+
+      if (existing) {
+        existing.isManagedLocal = true;
+        existing.installed = this.isInstalledCommand(existing.path);
+        continue;
+      }
+
+      commands.push(localCommand);
+    }
+  }
+
+  listCommands(projectPath = null, options = {}) {
     const commands = [];
+    const syncManagedLocalCommands = options.syncManagedLocalCommands === true;
 
-    // 获取用户级命令
-    const userCommands = scanCommandsDir(this.userCommandsDir, this.userCommandsDir, 'user');
-    commands.push(...userCommands);
+    this.mergeInstalledUserCommands(commands, { syncManagedLocalCommands });
+    this.mergeLocalUserCommands(commands);
 
     // 获取项目级命令（如果提供了项目路径）
     if (projectPath) {
       const projectCommandsDir = this.getProjectCommandsDir(projectPath);
-      const projectCommands = scanCommandsDir(projectCommandsDir, projectCommandsDir, 'project');
+      const projectCommands = scanCommandsDir(projectCommandsDir, projectCommandsDir, 'project', {
+        decorate: () => ({
+          installed: true,
+          isManagedLocal: false,
+          source: 'native-installed'
+        })
+      });
       commands.push(...projectCommands);
     }
 
     // 按名称排序
     commands.sort((a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase()));
+    const userCount = commands.filter(command => command.scope === 'user').length;
+    const projectCount = commands.length - userCount;
 
     return {
       commands,
       total: commands.length,
-      userCount: userCommands.length,
-      projectCount: commands.length - userCommands.length
+      userCount,
+      projectCount
     };
   }
 
@@ -292,7 +460,9 @@ class CommandsService {
    */
   async listAllCommands(projectPath = null, forceRefresh = false) {
     // 获取本地命令
-    const { commands: localCommands, userCount, projectCount } = this.listCommands(projectPath);
+    const { commands: localCommands, userCount, projectCount } = this.listCommands(projectPath, {
+      syncManagedLocalCommands: forceRefresh
+    });
 
     // 获取远程命令
     let remoteCommands = [];
@@ -340,25 +510,30 @@ class CommandsService {
       ? this.userCommandsDir
       : this.getProjectCommandsDir(projectPath);
 
-    const relativePath = namespace
+    const relativePath = normalizeCommandRelativePath(namespace
       ? path.join(namespace, `${name}.md`)
-      : `${name}.md`;
-
+      : `${name}.md`);
     const fullPath = path.join(baseDir, relativePath);
+    const managedPath = scope === 'user' ? this.getManagedCommandPath(relativePath) : '';
+    const activePath = fs.existsSync(fullPath)
+      ? fullPath
+      : (managedPath && fs.existsSync(managedPath) ? managedPath : '');
 
-    if (!fs.existsSync(fullPath)) {
+    if (!activePath) {
       return null;
     }
 
-    const content = fs.readFileSync(fullPath, 'utf-8');
+    const content = fs.readFileSync(activePath, 'utf-8');
     const { frontmatter, body } = parseFrontmatter(content);
+    const installed = fs.existsSync(fullPath);
+    const isManagedLocal = scope === 'user' && !!managedPath && fs.existsSync(managedPath);
 
     return {
       name,
       namespace,
       scope,
       path: relativePath,
-      fullPath,
+      fullPath: activePath,
       description: frontmatter.description || '',
       allowedTools: frontmatter['allowed-tools'] || '',
       argumentHint: frontmatter['argument-hint'] || '',
@@ -367,7 +542,10 @@ class CommandsService {
       subtask: frontmatter.subtask || '',
       body,
       fullContent: content,
-      updatedAt: fs.statSync(fullPath).mtime.getTime()
+      installed,
+      isManagedLocal,
+      source: installed ? 'native-installed' : 'local',
+      updatedAt: fs.statSync(activePath).mtime.getTime()
     };
   }
 
@@ -392,30 +570,28 @@ class CommandsService {
     ensureDir(targetDir);
 
     const filePath = path.join(targetDir, `${name}.md`);
+    const relativePath = normalizeCommandRelativePath(namespace ? path.join(namespace, `${name}.md`) : `${name}.md`);
+    const managedPath = scope === 'user' ? this.getManagedCommandPath(relativePath) : '';
 
     // 检查是否已存在
-    if (fs.existsSync(filePath)) {
+    if (fs.existsSync(filePath) || (managedPath && fs.existsSync(managedPath))) {
       throw new Error(`命令 "${name}" 已存在`);
     }
 
-    // 生成文件内容
-    const frontmatterData = {};
-    if (description) frontmatterData.description = description;
-    if (this.platform !== 'opencode') {
-      if (allowedTools) frontmatterData['allowed-tools'] = allowedTools;
-      if (argumentHint) frontmatterData['argument-hint'] = argumentHint;
-    }
-    if (agent) frontmatterData.agent = agent;
-    if (model) frontmatterData.model = model;
-    if (typeof subtask === 'boolean') frontmatterData.subtask = subtask;
-
-    let content = '';
-    if (Object.keys(frontmatterData).length > 0) {
-      content = generateCommandFrontmatter(frontmatterData) + '\n\n';
-    }
-    content += body || '';
+    const content = this.buildCommandContent({
+      description,
+      allowedTools,
+      argumentHint,
+      agent,
+      model,
+      subtask,
+      body
+    });
 
     fs.writeFileSync(filePath, content, 'utf-8');
+    if (managedPath) {
+      this.copyFileRecursive(filePath, managedPath);
+    }
 
     return this.getCommand(name, scope, projectPath, namespace);
   }
@@ -428,34 +604,34 @@ class CommandsService {
       ? this.userCommandsDir
       : this.getProjectCommandsDir(projectPath);
 
-    const relativePath = namespace
+    const relativePath = normalizeCommandRelativePath(namespace
       ? path.join(namespace, `${name}.md`)
-      : `${name}.md`;
-
+      : `${name}.md`);
     const filePath = path.join(baseDir, relativePath);
+    const managedPath = scope === 'user' ? this.getManagedCommandPath(relativePath) : '';
+    const hasManagedCopy = managedPath && fs.existsSync(managedPath);
 
-    if (!fs.existsSync(filePath)) {
+    if (!fs.existsSync(filePath) && !hasManagedCopy) {
       throw new Error(`命令 "${name}" 不存在`);
     }
 
-    // 生成文件内容
-    const frontmatterData = {};
-    if (description) frontmatterData.description = description;
-    if (this.platform !== 'opencode') {
-      if (allowedTools) frontmatterData['allowed-tools'] = allowedTools;
-      if (argumentHint) frontmatterData['argument-hint'] = argumentHint;
-    }
-    if (agent) frontmatterData.agent = agent;
-    if (model) frontmatterData.model = model;
-    if (typeof subtask === 'boolean') frontmatterData.subtask = subtask;
+    const content = this.buildCommandContent({
+      description,
+      allowedTools,
+      argumentHint,
+      agent,
+      model,
+      subtask,
+      body
+    });
 
-    let content = '';
-    if (Object.keys(frontmatterData).length > 0) {
-      content = generateCommandFrontmatter(frontmatterData) + '\n\n';
+    if (fs.existsSync(filePath)) {
+      fs.writeFileSync(filePath, content, 'utf-8');
+    }
+    if (managedPath) {
+      ensureDir(path.dirname(managedPath));
+      fs.writeFileSync(managedPath, content, 'utf-8');
     }
-    content += body || '';
-
-    fs.writeFileSync(filePath, content, 'utf-8');
 
     return this.getCommand(name, scope, projectPath, namespace);
   }
@@ -468,29 +644,27 @@ class CommandsService {
       ? this.userCommandsDir
       : this.getProjectCommandsDir(projectPath);
 
-    const relativePath = namespace
+    const relativePath = normalizeCommandRelativePath(namespace
       ? path.join(namespace, `${name}.md`)
-      : `${name}.md`;
-
+      : `${name}.md`);
     const filePath = path.join(baseDir, relativePath);
+    const managedPath = scope === 'user' ? this.getManagedCommandPath(relativePath) : '';
+    let removed = false;
 
-    if (!fs.existsSync(filePath)) {
-      return { success: false, message: '命令不存在' };
+    if (fs.existsSync(filePath)) {
+      fs.unlinkSync(filePath);
+      this.removeEmptyCommandDirs(baseDir, relativePath);
+      removed = true;
     }
 
-    fs.unlinkSync(filePath);
+    if (managedPath && fs.existsSync(managedPath)) {
+      fs.unlinkSync(managedPath);
+      this.removeEmptyCommandDirs(this.storageDir, relativePath);
+      removed = true;
+    }
 
-    // 如果目录为空，删除目录
-    if (namespace) {
-      const namespaceDir = path.join(baseDir, namespace);
-      try {
-        const remaining = fs.readdirSync(namespaceDir);
-        if (remaining.length === 0) {
-          fs.rmdirSync(namespaceDir);
-        }
-      } catch (err) {
-        // 忽略删除目录错误
-      }
+    if (!removed) {
+      return { success: false, message: '命令不存在' };
     }
 
     return { success: true, message: '命令已删除' };
@@ -557,11 +731,37 @@ class CommandsService {
     return this.repoScanner.installCommand(command);
   }
 
+  installLocalCommand(relativePath) {
+    const normalizedPath = normalizeCommandRelativePath(relativePath);
+    const managedPath = this.getManagedCommandPath(normalizedPath);
+    const targetPath = path.join(this.userCommandsDir, normalizedPath);
+
+    if (!fs.existsSync(managedPath)) {
+      throw new Error(`本地命令 "${normalizedPath}" 不存在`);
+    }
+
+    if (fs.existsSync(targetPath)) {
+      return { success: true, message: 'Already installed' };
+    }
+
+    this.copyFileRecursive(managedPath, targetPath);
+    return { success: true, message: 'Installed successfully' };
+  }
+
   /**
    * 卸载命令
    */
   uninstallCommand(relativePath) {
-    return this.repoScanner.uninstall(relativePath);
+    const normalizedPath = normalizeCommandRelativePath(relativePath);
+    const targetPath = path.join(this.userCommandsDir, normalizedPath);
+
+    if (fs.existsSync(targetPath)) {
+      fs.unlinkSync(targetPath);
+      this.removeEmptyCommandDirs(this.userCommandsDir, normalizedPath);
+      return { success: true, message: 'Uninstalled successfully' };
+    }
+
+    return { success: true, message: 'Not installed' };
   }
 
   // ==================== 格式转换 ====================

package/src/server/services/config-export-service.js

@@ -14,7 +14,7 @@ const opencodeChannelsService = require('./opencode-channels');
 const { AgentsService } = require('./agents-service');
 const { CommandsService } = require('./commands-service');
 const { SkillService } = require('./skill-service');
-const { PATHS, NATIVE_PATHS } = require('../../config/paths');
+const { PATHS, NATIVE_PATHS, getNativePathDir } = require('../../config/paths');
 
 const CONFIG_VERSION = '1.4.0';
 const SKILL_FILE_ENCODING = 'base64';
@@ -25,8 +25,8 @@ const LEGACY_CC_TOOL_DIR = PATHS.base;
 const CLAUDE_SETTINGS_PATH = NATIVE_PATHS.claude.settings;
 const LEGACY_PLUGINS_DIR = path.join(LEGACY_CC_TOOL_DIR, 'plugins', 'installed');
 const LEGACY_PLUGINS_REGISTRY = path.join(LEGACY_CC_TOOL_DIR, 'plugins', 'registry.json');
-const CLAUDE_PLUGINS_DIR = path.join(path.dirname(NATIVE_PATHS.claude.settings), 'plugins');
-const NATIVE_PLUGINS_REGISTRY = path.join(CLAUDE_PLUGINS_DIR, 'installed_plugins.json');
+const CLAUDE_PLUGINS_DIR = NATIVE_PATHS.claude.plugins;
+const NATIVE_PLUGINS_REGISTRY = NATIVE_PATHS.claude.installedPlugins;
 const PLUGIN_IGNORE_DIRS = new Set(['.git', 'node_modules', '.DS_Store']);
 const PLUGIN_IGNORE_FILES = new Set(['.DS_Store']);
 const PLUGIN_SENSITIVE_PATTERNS = [
@@ -44,7 +44,7 @@ const CC_PROMPTS_PATH = PATHS.prompts;
 const CC_SECURITY_PATH = PATHS.security;
 const LEGACY_UI_CONFIG_PATH = PATHS.uiConfig;
 const LEGACY_NOTIFY_HOOK_PATH = PATHS.notifyHook;
-const GEMINI_SETTINGS_PATH = path.join(path.dirname(NATIVE_PATHS.gemini.env), 'settings.json');
+const GEMINI_SETTINGS_PATH = NATIVE_PATHS.gemini.settings;
 const AGENT_PLATFORMS = ['claude', 'codex', 'opencode'];
 const COMMAND_PLATFORMS = ['claude', 'opencode'];
 const SKILL_PLATFORMS = ['claude', 'codex', 'gemini', 'opencode'];
@@ -156,7 +156,7 @@ function writeJsonFileAbsolute(filePath, data, overwrite, options = {}) {
     return 'failed';
   }
   if (fs.existsSync(filePath) && !overwrite) return 'skipped';
-  ensureDir(path.dirname(filePath));
+  ensureDir(getNativePathDir(filePath));
   fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf8');
   if (options.mode) {
     try {
@@ -173,7 +173,7 @@ function writeTextFileAbsolute(filePath, content, overwrite, options = {}) {
     return 'failed';
   }
   if (fs.existsSync(filePath) && !overwrite) return 'skipped';
-  ensureDir(path.dirname(filePath));
+  ensureDir(getNativePathDir(filePath));
   fs.writeFileSync(filePath, content, 'utf8');
   if (options.mode) {
     try {
@@ -507,7 +507,7 @@ function syncImportedChannelsToNativeConfigs(importChannelsByType, nativeConfigs
         ]
       );
       if (persistedClaudeChannel?.id) {
-        ensureDir(path.dirname(NATIVE_PATHS.claude.settings));
+        ensureDir(NATIVE_PATHS.claude.dir);
         channelsService.applyChannelToSettings(persistedClaudeChannel.id);
       }
     }

package/src/server/services/config-registry-service.js

@@ -17,12 +17,11 @@ const REGISTRY_FILE = PATHS.configRegistry;
 const CONFIGS_DIR = PATHS.configs;
 
 // Claude Code native directories
-const CLAUDE_HOME_DIR = path.dirname(NATIVE_PATHS.claude.settings);
 const CLAUDE_DIRS = {
-  skills: path.join(CLAUDE_HOME_DIR, 'skills'),
-  commands: path.join(CLAUDE_HOME_DIR, 'commands'),
-  agents: path.join(CLAUDE_HOME_DIR, 'agents'),
-  plugins: path.join(CLAUDE_HOME_DIR, 'plugins')
+  skills: NATIVE_PATHS.claude.skills,
+  commands: NATIVE_PATHS.claude.commands,
+  agents: NATIVE_PATHS.claude.agents,
+  plugins: NATIVE_PATHS.claude.plugins
 };
 
 // Valid config types