coding-tool-x 3.5.8 → 3.5.10

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, PATHS } = require('../../config/paths');
+const { NATIVE_PATHS } = require('../../config/paths');
 const {
   parseCommandContent,
   parseFrontmatter
@@ -17,21 +17,18 @@ const {
 // 默认仓库源
 const DEFAULT_REPOS = [];
 const SUPPORTED_PLATFORMS = ['claude', 'opencode'];
-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 OPENCODE_CONFIG_DIR = NATIVE_PATHS.opencode.config;
+const CLAUDE_COMMANDS_DIR = path.join(path.dirname(NATIVE_PATHS.claude.settings), 'commands');
 
 const PLATFORM_CONFIG = {
   claude: {
     userCommandsDir: CLAUDE_COMMANDS_DIR,
-    storageDir: PATHS.localCommands.claude,
     projectCommandsDir: (projectPath) => path.join(projectPath, '.claude', 'commands'),
     repoType: 'commands'
   },
   opencode: {
-    userCommandsDir: OPENCODE_COMMANDS_DIR,
-    storageDir: PATHS.localCommands.opencode,
-    legacyUserCommandsDir: OPENCODE_LEGACY_COMMANDS_DIR,
+    userCommandsDir: path.join(OPENCODE_CONFIG_DIR, 'commands'),
+    legacyUserCommandsDir: path.join(OPENCODE_CONFIG_DIR, 'command'),
     projectCommandsDir: (projectPath) => {
       const modern = path.join(projectPath, '.opencode', 'commands');
       const legacy = path.join(projectPath, '.opencode', 'command');
@@ -57,25 +54,6 @@ 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 字符串（用于命令创建/更新）
  */
@@ -111,7 +89,7 @@ function generateCommandFrontmatter(data) {
 /**
  * 递归扫描目录获取命令文件
  */
-function scanCommandsDir(dir, basePath, scope, options = {}) {
+function scanCommandsDir(dir, basePath, scope) {
   const commands = [];
 
   if (!fs.existsSync(dir)) {
@@ -126,7 +104,7 @@ function scanCommandsDir(dir, basePath, scope, options = {}) {
 
       if (entry.isDirectory() && !entry.name.startsWith('.')) {
         // 递归扫描子目录
-        const subCommands = scanCommandsDir(fullPath, basePath, scope, options);
+        const subCommands = scanCommandsDir(fullPath, basePath, scope);
         commands.push(...subCommands);
       } else if (entry.isFile() && entry.name.endsWith('.md')) {
         // 解析命令文件
@@ -135,10 +113,11 @@ function scanCommandsDir(dir, basePath, scope, options = {}) {
           const { frontmatter, body } = parseFrontmatter(content);
 
           // 计算相对路径和命令名
-          const relativePath = normalizeCommandRelativePath(path.relative(basePath, fullPath));
+          const relativePath = path.relative(basePath, fullPath);
           const commandName = entry.name.replace(/\.md$/, '');
           const namespace = path.dirname(relativePath);
-          const command = {
+
+          commands.push({
             name: commandName,
             namespace: namespace === '.' ? null : namespace,
             scope,
@@ -153,15 +132,7 @@ function scanCommandsDir(dir, basePath, scope, options = {}) {
             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);
         }
@@ -269,7 +240,6 @@ 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)) {
@@ -280,7 +250,6 @@ class CommandsService {
     this.projectCommandsDir = config.projectCommandsDir;
     this.repoScanner = new CommandsRepoScanner(this.platform, this.userCommandsDir);
     ensureDir(this.userCommandsDir);
-    ensureDir(this.storageDir);
   }
 
   getProjectCommandsDir(projectPath) {
@@ -292,165 +261,28 @@ class CommandsService {
    * 获取所有命令列表
    * @param {string} projectPath - 项目路径（可选，用于获取项目级命令）
    */
-  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 = {}) {
+  listCommands(projectPath = null) {
     const commands = [];
-    const syncManagedLocalCommands = options.syncManagedLocalCommands === true;
 
-    this.mergeInstalledUserCommands(commands, { syncManagedLocalCommands });
-    this.mergeLocalUserCommands(commands);
+    // 获取用户级命令
+    const userCommands = scanCommandsDir(this.userCommandsDir, this.userCommandsDir, 'user');
+    commands.push(...userCommands);
 
     // 获取项目级命令（如果提供了项目路径）
     if (projectPath) {
       const projectCommandsDir = this.getProjectCommandsDir(projectPath);
-      const projectCommands = scanCommandsDir(projectCommandsDir, projectCommandsDir, 'project', {
-        decorate: () => ({
-          installed: true,
-          isManagedLocal: false,
-          source: 'native-installed'
-        })
-      });
+      const projectCommands = scanCommandsDir(projectCommandsDir, projectCommandsDir, 'project');
       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,
-      projectCount
+      userCount: userCommands.length,
+      projectCount: commands.length - userCommands.length
     };
   }
 
@@ -460,9 +292,7 @@ class CommandsService {
    */
   async listAllCommands(projectPath = null, forceRefresh = false) {
     // 获取本地命令
-    const { commands: localCommands, userCount, projectCount } = this.listCommands(projectPath, {
-      syncManagedLocalCommands: forceRefresh
-    });
+    const { commands: localCommands, userCount, projectCount } = this.listCommands(projectPath);
 
     // 获取远程命令
     let remoteCommands = [];
@@ -510,30 +340,25 @@ class CommandsService {
       ? this.userCommandsDir
       : this.getProjectCommandsDir(projectPath);
 
-    const relativePath = normalizeCommandRelativePath(namespace
+    const relativePath = 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 (!activePath) {
+    if (!fs.existsSync(fullPath)) {
       return null;
     }
 
-    const content = fs.readFileSync(activePath, 'utf-8');
+    const content = fs.readFileSync(fullPath, '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: activePath,
+      fullPath,
       description: frontmatter.description || '',
       allowedTools: frontmatter['allowed-tools'] || '',
       argumentHint: frontmatter['argument-hint'] || '',
@@ -542,10 +367,7 @@ class CommandsService {
       subtask: frontmatter.subtask || '',
       body,
       fullContent: content,
-      installed,
-      isManagedLocal,
-      source: installed ? 'native-installed' : 'local',
-      updatedAt: fs.statSync(activePath).mtime.getTime()
+      updatedAt: fs.statSync(fullPath).mtime.getTime()
     };
   }
 
@@ -570,28 +392,30 @@ 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) || (managedPath && fs.existsSync(managedPath))) {
+    if (fs.existsSync(filePath)) {
       throw new Error(`命令 "${name}" 已存在`);
     }
 
-    const content = this.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;
 
-    fs.writeFileSync(filePath, content, 'utf-8');
-    if (managedPath) {
-      this.copyFileRecursive(filePath, managedPath);
+    let content = '';
+    if (Object.keys(frontmatterData).length > 0) {
+      content = generateCommandFrontmatter(frontmatterData) + '\n\n';
     }
+    content += body || '';
+
+    fs.writeFileSync(filePath, content, 'utf-8');
 
     return this.getCommand(name, scope, projectPath, namespace);
   }
@@ -604,34 +428,34 @@ class CommandsService {
       ? this.userCommandsDir
       : this.getProjectCommandsDir(projectPath);
 
-    const relativePath = normalizeCommandRelativePath(namespace
+    const relativePath = 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) && !hasManagedCopy) {
+    if (!fs.existsSync(filePath)) {
       throw new Error(`命令 "${name}" 不存在`);
     }
 
-    const content = this.buildCommandContent({
-      description,
-      allowedTools,
-      argumentHint,
-      agent,
-      model,
-      subtask,
-      body
-    });
-
-    if (fs.existsSync(filePath)) {
-      fs.writeFileSync(filePath, content, 'utf-8');
+    // 生成文件内容
+    const frontmatterData = {};
+    if (description) frontmatterData.description = description;
+    if (this.platform !== 'opencode') {
+      if (allowedTools) frontmatterData['allowed-tools'] = allowedTools;
+      if (argumentHint) frontmatterData['argument-hint'] = argumentHint;
     }
-    if (managedPath) {
-      ensureDir(path.dirname(managedPath));
-      fs.writeFileSync(managedPath, content, 'utf-8');
+    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 || '';
+
+    fs.writeFileSync(filePath, content, 'utf-8');
 
     return this.getCommand(name, scope, projectPath, namespace);
   }
@@ -644,27 +468,29 @@ class CommandsService {
       ? this.userCommandsDir
       : this.getProjectCommandsDir(projectPath);
 
-    const relativePath = normalizeCommandRelativePath(namespace
+    const relativePath = 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)) {
-      fs.unlinkSync(filePath);
-      this.removeEmptyCommandDirs(baseDir, relativePath);
-      removed = true;
+    if (!fs.existsSync(filePath)) {
+      return { success: false, message: '命令不存在' };
     }
 
-    if (managedPath && fs.existsSync(managedPath)) {
-      fs.unlinkSync(managedPath);
-      this.removeEmptyCommandDirs(this.storageDir, relativePath);
-      removed = true;
-    }
+    fs.unlinkSync(filePath);
 
-    if (!removed) {
-      return { success: false, message: '命令不存在' };
+    // 如果目录为空，删除目录
+    if (namespace) {
+      const namespaceDir = path.join(baseDir, namespace);
+      try {
+        const remaining = fs.readdirSync(namespaceDir);
+        if (remaining.length === 0) {
+          fs.rmdirSync(namespaceDir);
+        }
+      } catch (err) {
+        // 忽略删除目录错误
+      }
     }
 
     return { success: true, message: '命令已删除' };
@@ -731,37 +557,11 @@ 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) {
-    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' };
+    return this.repoScanner.uninstall(relativePath);
   }
 
   // ==================== 格式转换 ====================

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, getNativePathDir } = require('../../config/paths');
+const { PATHS, NATIVE_PATHS } = 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 = NATIVE_PATHS.claude.plugins;
-const NATIVE_PLUGINS_REGISTRY = NATIVE_PATHS.claude.installedPlugins;
+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 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 = NATIVE_PATHS.gemini.settings;
+const GEMINI_SETTINGS_PATH = path.join(path.dirname(NATIVE_PATHS.gemini.env), 'settings.json');
 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(getNativePathDir(filePath));
+  ensureDir(path.dirname(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(getNativePathDir(filePath));
+  ensureDir(path.dirname(filePath));
   fs.writeFileSync(filePath, content, 'utf8');
   if (options.mode) {
     try {
@@ -507,7 +507,7 @@ function syncImportedChannelsToNativeConfigs(importChannelsByType, nativeConfigs
         ]
       );
       if (persistedClaudeChannel?.id) {
-        ensureDir(NATIVE_PATHS.claude.dir);
+        ensureDir(path.dirname(NATIVE_PATHS.claude.settings));
         channelsService.applyChannelToSettings(persistedClaudeChannel.id);
       }
     }

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

@@ -17,11 +17,12 @@ 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: NATIVE_PATHS.claude.skills,
-  commands: NATIVE_PATHS.claude.commands,
-  agents: NATIVE_PATHS.claude.agents,
-  plugins: NATIVE_PATHS.claude.plugins
+  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')
 };
 
 // Valid config types
@@ -511,7 +512,7 @@ class ConfigRegistryService {
           this._importFileBasedConfigs(type, sourceDir, destDir, entryRelativePath, registry, result);
         } else if (entry.isFile() && entry.name.endsWith('.md')) {
           // This is a config file
-          const name = entryRelativePath; // Key is the relative path
+          const name = normalizeRelativeConfigName(entryRelativePath);
 
           // Skip if already in registry
           if (registry[type][name]) {
@@ -520,8 +521,8 @@ class ConfigRegistryService {
           }
 
           // Copy file to cc-tool configs
-          const sourcePath = path.join(sourceDir, entryRelativePath);
-          const destPath = path.join(destDir, entryRelativePath);
+          const sourcePath = path.join(sourceDir, name);
+          const destPath = path.join(destDir, name);
 
           try {
             // Ensure destination directory exists
@@ -800,7 +801,7 @@ class ConfigRegistryService {
         if (entry.isDirectory()) {
           this._syncFileBasedRegistry(type, baseDir, entryRelativePath, registry, result);
         } else if (entry.isFile() && entry.name.endsWith('.md')) {
-          const name = entryRelativePath;
+          const name = normalizeRelativeConfigName(entryRelativePath);
 
           if (!registry[type][name]) {
             registry[type][name] = {