coding-tool-x 3.5.8 → 3.5.10

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

@@ -6,16 +6,20 @@
 
 const fs = require('fs');
 const path = require('path');
-const { PATHS, getNativePlatformPromptPath } = require('../../config/paths');
+const os = require('os');
+const { NATIVE_PATHS, PATHS } = require('../../config/paths');
+const { resolvePreferredHomeDir } = require('../../utils/home-dir');
+
+const HOME_DIR = resolvePreferredHomeDir(process.platform, process.env, os.homedir());
 
 // Prompts 配置文件路径
 const PROMPTS_FILE = PATHS.prompts;
 
 // 各平台提示词文件路径
-const CLAUDE_PROMPT_PATH = getNativePlatformPromptPath('claude');
-const CODEX_PROMPT_PATH = getNativePlatformPromptPath('codex');
-const GEMINI_PROMPT_PATH = getNativePlatformPromptPath('gemini');
-const OPENCODE_PROMPT_PATH = getNativePlatformPromptPath('opencode');
+const CLAUDE_PROMPT_PATH = path.join(HOME_DIR, '.claude', 'CLAUDE.md');
+const CODEX_PROMPT_PATH = path.join(HOME_DIR, '.codex', 'AGENTS.md');
+const GEMINI_PROMPT_PATH = path.join(HOME_DIR, '.gemini', 'GEMINI.md');
+const OPENCODE_PROMPT_PATH = path.join(NATIVE_PATHS.opencode.config, 'AGENTS.md');
 
 function normalizeApps(apps = {}, defaults = { claude: true, codex: true, gemini: true, opencode: false }) {
   return {

package/src/server/services/sessions.js

@@ -14,11 +14,8 @@ const { globalCache, CacheKeys } = require('./enhanced-cache');
 const { PATHS, NATIVE_PATHS } = require('../../config/paths');
 
 const CLAUDE_PROJECTS_DIR = NATIVE_PATHS.claude.projects;
-const CODEX_PROJECTS_DIR = NATIVE_PATHS.codex.projects;
-const GEMINI_PROJECTS_DIR = NATIVE_PATHS.gemini.projects;
-const PROJECT_PATH_CACHE_TTL_MS = 5 * 60 * 1000;
-const MAX_PROJECT_PATH_CACHE_ENTRIES = 500;
-let projectPathResolutionCache = new Map();
+const CODEX_PROJECTS_DIR = path.join(path.dirname(NATIVE_PATHS.codex.config), 'projects');
+const GEMINI_PROJECTS_DIR = path.join(path.dirname(NATIVE_PATHS.gemini.env), 'projects');
 
 // Base directory for cc-tool data
 function getCcToolDir() {
@@ -89,96 +86,113 @@ function saveForkRelations(relations) {
   fs.writeFileSync(relationsFile, JSON.stringify(relations, null, 2), 'utf8');
 }
 
-// Get all projects with stats (async version)
-async function getProjects(config) {
-  const projectsDir = config.projectsDir;
+function invalidateSessionResultCache(projectName) {
+  if (!projectName) return;
+  globalCache.delete(`${CacheKeys.SESSIONS}${projectName}`);
+}
 
-  if (!fs.existsSync(projectsDir)) {
-    return [];
+function getClaudeForkMessageText(content) {
+  if (typeof content === 'string') {
+    return content === 'Warmup' ? '' : content;
   }
 
-  const entries = await fs.promises.readdir(projectsDir, { withFileTypes: true });
-  return entries
-    .filter(entry => entry.isDirectory())
-    .map(entry => entry.name);
-}
+  if (!Array.isArray(content)) {
+    return '';
+  }
 
-function getProjectPathCacheKey(encodedName) {
-  return `${process.platform}:${encodedName}`;
+  const parts = [];
+  for (const item of content) {
+    if (item?.type === 'text' && item.text) {
+      parts.push(item.text);
+    } else if (item?.type === 'image') {
+      parts.push('[图片]');
+    }
+  }
+
+  return parts.join('\n\n').trim();
 }
 
-function cloneProjectPathResolution(value) {
+function splitTextPreserveEol(content) {
+  const eol = content.includes('\r\n') ? '\r\n' : '\n';
+  const hasTrailingEol = content.endsWith('\r\n') || content.endsWith('\n');
   return {
-    fullPath: value?.fullPath || '',
-    projectName: value?.projectName || ''
+    lines: content.split(/\r?\n/),
+    eol,
+    hasTrailingEol
   };
 }
 
-function getCachedProjectPathResolution(encodedName) {
-  const cacheKey = getProjectPathCacheKey(encodedName);
-  const cached = projectPathResolutionCache.get(cacheKey);
-  if (!cached) {
-    return null;
-  }
+function joinTextPreserveEol(lines, eol, hasTrailingEol) {
+  const text = lines.join(eol);
+  return hasTrailingEol ? `${text}${eol}` : text;
+}
 
-  if (cached.expiresAt <= Date.now()) {
-    projectPathResolutionCache.delete(cacheKey);
-    return null;
+function sliceClaudeSessionContentByUserMessage(content, afterUserMessageNumber) {
+  if (!Number.isInteger(afterUserMessageNumber) || afterUserMessageNumber <= 0) {
+    return content;
   }
 
-  return cloneProjectPathResolution(cached.value);
-}
+  const { lines, eol, hasTrailingEol } = splitTextPreserveEol(content);
+  const keptLines = [];
+  let matchedUserMessages = 0;
 
-function setCachedProjectPathResolution(encodedName, value) {
-  const cacheKey = getProjectPathCacheKey(encodedName);
-  projectPathResolutionCache.delete(cacheKey);
-  projectPathResolutionCache.set(cacheKey, {
-    expiresAt: Date.now() + PROJECT_PATH_CACHE_TTL_MS,
-    value: cloneProjectPathResolution(value)
-  });
+  for (const line of lines) {
+    if (!line.trim()) {
+      keptLines.push(line);
+      continue;
+    }
+
+    let json;
+    try {
+      json = JSON.parse(line);
+    } catch (err) {
+      keptLines.push(line);
+      continue;
+    }
+
+    keptLines.push(line);
+
+    if (json.type !== 'user') {
+      continue;
+    }
 
-  while (projectPathResolutionCache.size > MAX_PROJECT_PATH_CACHE_ENTRIES) {
-    const oldestKey = projectPathResolutionCache.keys().next().value;
-    if (!oldestKey) {
-      break;
+    const userText = getClaudeForkMessageText(json.message?.content);
+    if (!userText) {
+      continue;
+    }
+
+    matchedUserMessages += 1;
+    if (matchedUserMessages >= afterUserMessageNumber) {
+      return joinTextPreserveEol(keptLines, eol, hasTrailingEol);
     }
-    projectPathResolutionCache.delete(oldestKey);
   }
+
+  throw new Error(`afterUserMessageNumber ${afterUserMessageNumber} exceeds available user messages (${matchedUserMessages})`);
 }
 
-function clearProjectPathResolutionCache(encodedName) {
-  if (!encodedName) {
-    projectPathResolutionCache.clear();
-    return;
+// Get all projects with stats (async version)
+async function getProjects(config) {
+  const projectsDir = config.projectsDir;
+
+  if (!fs.existsSync(projectsDir)) {
+    return [];
   }
 
-  projectPathResolutionCache.delete(getProjectPathCacheKey(encodedName));
+  const entries = await fs.promises.readdir(projectsDir, { withFileTypes: true });
+  return entries
+    .filter(entry => entry.isDirectory())
+    .map(entry => entry.name);
 }
 
 // Parse real project path from encoded name
 // macOS/Linux: "-Users-lilithgames-work-project" -> "/Users/lilithgames/work/project"
 // Windows: "C--Users-admin-Desktop-project" -> "C:\Users\admin\Desktop\project"
 function parseRealProjectPath(encodedName) {
-  const normalizedEncodedName = String(encodedName || '').trim();
-  const cached = getCachedProjectPathResolution(normalizedEncodedName);
-  if (cached) {
-    return cached;
-  }
-
   const isWindows = process.platform === 'win32';
-  const fallbackFromSessions = tryResolvePathFromSessions(normalizedEncodedName);
-
-  if (fallbackFromSessions?.fullPath) {
-    const resolved = {
-      fullPath: fallbackFromSessions.fullPath,
-      projectName: fallbackFromSessions.projectName || path.basename(fallbackFromSessions.fullPath) || normalizedEncodedName
-    };
-    setCachedProjectPathResolution(normalizedEncodedName, resolved);
-    return resolved;
-  }
+  const fallbackFromSessions = tryResolvePathFromSessions(encodedName);
 
   // Detect Windows drive letter (e.g., "C--Users-admin")
-  const windowsDriveMatch = normalizedEncodedName.match(/^([A-Z])--(.+)$/);
+  const windowsDriveMatch = encodedName.match(/^([A-Z])--(.+)$/);
 
   if (isWindows && windowsDriveMatch) {
     // Windows path with drive letter
@@ -237,15 +251,13 @@ function parseRealProjectPath(encodedName) {
       currentPath = driveLetter + ':\\' + realSegments.join('\\');
     }
 
-    const resolved = {
-      fullPath: validateProjectPath(currentPath) || (driveLetter + ':\\' + restPath.replace(/-/g, '\\')),
-      projectName: realSegments[realSegments.length - 1] || normalizedEncodedName
+    return {
+      fullPath: validateProjectPath(currentPath) || fallbackFromSessions?.fullPath || (driveLetter + ':\\' + restPath.replace(/-/g, '\\')),
+      projectName: fallbackFromSessions?.projectName || realSegments[realSegments.length - 1] || encodedName
     };
-    setCachedProjectPathResolution(normalizedEncodedName, resolved);
-    return resolved;
   } else {
     // Unix-like path (macOS/Linux) or fallback
-    const pathStr = normalizedEncodedName.replace(/^-/, '/').replace(/-/g, '/');
+    const pathStr = encodedName.replace(/^-/, '/').replace(/-/g, '/');
     const segments = pathStr.split('/').filter(s => s);
 
     // Build path from left to right, checking existence
@@ -297,12 +309,10 @@ function parseRealProjectPath(encodedName) {
       currentPath = '/' + realSegments.join('/');
     }
 
-    const resolved = {
-      fullPath: validateProjectPath(currentPath) || pathStr,
-      projectName: realSegments[realSegments.length - 1] || normalizedEncodedName
+    return {
+      fullPath: validateProjectPath(currentPath) || fallbackFromSessions?.fullPath || pathStr,
+      projectName: fallbackFromSessions?.projectName || realSegments[realSegments.length - 1] || encodedName
     };
-    setCachedProjectPathResolution(normalizedEncodedName, resolved);
-    return resolved;
   }
 }
 
@@ -421,20 +431,27 @@ async function buildProjectsWithStats(config) {
         const files = await fs.promises.readdir(projectPath);
         const jsonlFiles = files.filter(f => f.endsWith('.jsonl') && !f.startsWith('agent-'));
 
+        // Filter: only count sessions that have actual messages (in parallel)
         const sessionChecks = await Promise.all(
-          jsonlFiles.map(async (fileName) => {
-            const filePath = path.join(projectPath, fileName);
-            const stats = await fs.promises.stat(filePath);
-            const hasMessages = await hasActualMessages(filePath, stats);
-            return hasMessages ? stats.mtime.getTime() : null;
+          jsonlFiles.map(async (f) => {
+            const filePath = path.join(projectPath, f);
+            const hasMessages = await hasActualMessages(filePath);
+            return hasMessages ? f : null;
           })
         );
 
-        const activeSessionTimes = sessionChecks.filter((mtimeMs) => Number.isFinite(mtimeMs));
-        sessionCount = activeSessionTimes.length;
+        const sessionFilesWithMessages = sessionChecks.filter(f => f !== null);
+        sessionCount = sessionFilesWithMessages.length;
 
-        if (activeSessionTimes.length > 0) {
-          lastUsed = Math.max(...activeSessionTimes);
+        // Find most recent session (only from sessions with messages)
+        if (sessionFilesWithMessages.length > 0) {
+          const statPromises = sessionFilesWithMessages.map(async (f) => {
+            const filePath = path.join(projectPath, f);
+            const stat = await fs.promises.stat(filePath);
+            return stat.mtime.getTime();
+          });
+          const stats = await Promise.all(statPromises);
+          lastUsed = Math.max(...stats);
         }
       } catch (err) {
         // Ignore errors
@@ -482,9 +499,9 @@ function getProjectAndSessionCounts(config) {
 }
 
 // Check if a session file has actual messages (async with enhanced caching)
-async function hasActualMessages(filePath, statsOverride = null) {
+async function hasActualMessages(filePath) {
   try {
-    const stats = statsOverride || await fs.promises.stat(filePath);
+    const stats = await fs.promises.stat(filePath);
 
     // Check enhanced cache first
     const cacheKey = `${CacheKeys.HAS_MESSAGES}${filePath}:${stats.mtime.getTime()}`;
@@ -652,11 +669,12 @@ function deleteSession(config, projectName, sessionId) {
 
   fs.unlinkSync(sessionFile);
   invalidateProjectsCache(config);
+  invalidateSessionResultCache(projectName);
   return { success: true };
 }
 
 // Fork a session
-function forkSession(config, projectName, sessionId) {
+function forkSession(config, projectName, sessionId, options = {}) {
   const projectDir = path.join(config.projectsDir, projectName);
   const sessionFile = path.join(projectDir, sessionId + '.jsonl');
 
@@ -665,7 +683,11 @@ function forkSession(config, projectName, sessionId) {
   }
 
   // Read the original session
-  const content = fs.readFileSync(sessionFile, 'utf8');
+  const originalContent = fs.readFileSync(sessionFile, 'utf8');
+  const content = sliceClaudeSessionContentByUserMessage(
+    originalContent,
+    options.afterUserMessageNumber
+  );
 
   // Generate new session ID (UUID v4)
   const newSessionId = crypto.randomUUID();
@@ -678,9 +700,19 @@ function forkSession(config, projectName, sessionId) {
   const forkRelations = getForkRelations();
   forkRelations[newSessionId] = sessionId;
   saveForkRelations(forkRelations);
+  if (options.alias) {
+    const { setAlias } = require('./alias');
+    setAlias(newSessionId, options.alias);
+  }
   invalidateProjectsCache(config);
+  invalidateSessionResultCache(projectName);
 
-  return { newSessionId, forkedFrom: sessionId };
+  return {
+    newSessionId,
+    forkedFrom: sessionId,
+    alias: options.alias || null,
+    afterUserMessageNumber: options.afterUserMessageNumber || null
+  };
 }
 
 // Get session order for a project
@@ -725,13 +757,14 @@ function saveSessionOrder(projectName, order) {
 // Delete a project (remove the entire project directory)
 function deleteProject(config, projectName) {
   const projectDir = path.join(config.projectsDir, projectName);
-  const existed = fs.existsSync(projectDir);
 
-  if (existed) {
-    // Recursively delete the directory
-    fs.rmSync(projectDir, { recursive: true, force: true });
+  if (!fs.existsSync(projectDir)) {
+    throw new Error('Project not found');
   }
 
+  // Recursively delete the directory
+  fs.rmSync(projectDir, { recursive: true, force: true });
+
   // Remove from order file if exists
   const order = getProjectOrder(config);
   const newOrder = order.filter(name => name !== projectName);
@@ -740,11 +773,7 @@ function deleteProject(config, projectName) {
   }
 
   invalidateProjectsCache(config);
-  clearProjectPathResolutionCache(projectName);
-  return {
-    success: true,
-    alreadyDeleted: !existed
-  };
+  return { success: true };
 }
 
 // Search sessions for keyword

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

@@ -18,7 +18,7 @@ const {
   parseSkillContent,
 } = require('./format-converter');
 const { maskToken } = require('./oauth-utils');
-const { NATIVE_PATHS, HOME_DIR, PATHS, getNativePlatformSkillsDir } = require('../../config/paths');
+const { NATIVE_PATHS, HOME_DIR, PATHS } = require('../../config/paths');
 
 const SUPPORTED_PLATFORMS = ['claude', 'codex', 'gemini', 'opencode'];
 const SUPPORTED_REPO_PROVIDERS = ['github', 'gitlab', 'local'];
@@ -166,25 +166,25 @@ const DEFAULT_REPOS_BY_PLATFORM = {
 
 const PLATFORM_CONFIG = {
   claude: {
-    installDir: getNativePlatformSkillsDir('claude'),
+    installDir: path.join(HOME_DIR, '.claude', 'skills'),
     storageDir: PATHS.localSkills.claude,
     reposFile: PATHS.skillRepos.claude,
     cacheFile: PATHS.skillCaches.claude
   },
   codex: {
-    installDir: getNativePlatformSkillsDir('codex'),
+    installDir: path.join(HOME_DIR, '.codex', 'skills'),
     storageDir: PATHS.localSkills.codex,
     reposFile: PATHS.skillRepos.codex,
     cacheFile: PATHS.skillCaches.codex
   },
   gemini: {
-    installDir: getNativePlatformSkillsDir('gemini'),
+    installDir: path.join(HOME_DIR, '.gemini', 'skills'),
     storageDir: PATHS.localSkills.gemini,
     reposFile: PATHS.skillRepos.gemini,
     cacheFile: PATHS.skillCaches.gemini
   },
   opencode: {
-    installDir: getNativePlatformSkillsDir('opencode'),
+    installDir: path.join(NATIVE_PATHS.opencode.config, 'skills'),
     storageDir: PATHS.localSkills.opencode,
     reposFile: PATHS.skillRepos.opencode,
     cacheFile: PATHS.skillCaches.opencode
@@ -248,12 +248,11 @@ class SkillService {
     }
   }
 
-  prepareSkills(skills = [], options = {}) {
+  prepareSkills(skills = []) {
     const preparedSkills = Array.isArray(skills)
       ? skills.map(skill => ({ ...skill }))
       : [];
 
-    this.mergeInstalledSkills(preparedSkills, options);
     this.mergeLocalSkills(preparedSkills);
     this.deduplicateSkills(preparedSkills);
     preparedSkills.sort((a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase()));
@@ -538,8 +537,6 @@ class SkillService {
    * 获取所有技能列表（带缓存）
    */
   async listSkills(forceRefresh = false) {
-    const prepareOptions = { syncManagedLocalSkills: forceRefresh };
-
     // 强制刷新时仅清空内存缓存，保留磁盘缓存作为回退来源
     if (forceRefresh) {
       this.clearCache();
@@ -550,11 +547,11 @@ class SkillService {
     // 检查内存缓存
     if (!forceRefresh && Array.isArray(this.skillsCache) && this.skillsCache.length > 0) {
       if (Array.isArray(fileCache) && fileCache.length > this.skillsCache.length) {
-        this.skillsCache = this.prepareSkills(fileCache, prepareOptions);
+        this.skillsCache = this.prepareSkills(fileCache);
         this.cacheTime = Date.now();
         return this.skillsCache;
       }
-      this.skillsCache = this.prepareSkills(this.skillsCache, prepareOptions);
+      this.skillsCache = this.prepareSkills(this.skillsCache);
       this.cacheTime = Date.now();
       return this.skillsCache;
     }
@@ -562,7 +559,7 @@ class SkillService {
     // 检查文件缓存
     if (!forceRefresh) {
       if (fileCache && fileCache.length > 0) {
-        this.skillsCache = this.prepareSkills(fileCache, prepareOptions);
+        this.skillsCache = this.prepareSkills(fileCache);
         this.cacheTime = Date.now();
         return this.skillsCache;
       }
@@ -603,10 +600,10 @@ class SkillService {
       }
     }
 
-    const preparedSkills = this.prepareSkills(skills, prepareOptions);
+    const preparedSkills = this.prepareSkills(skills);
 
     const hasUsableFileCache = Array.isArray(fileCache) && fileCache.length > 0;
-    const preparedFileCache = hasUsableFileCache ? this.prepareSkills(fileCache, prepareOptions) : null;
+    const preparedFileCache = hasUsableFileCache ? this.prepareSkills(fileCache) : null;
     const shouldUseStaleFileCache = hasUsableFileCache && (
       (enabledRemoteRepos.length > 0 && remoteFailureCount === enabledRemoteRepos.length) ||
       (remoteFailureCount > 0 && preparedFileCache.length > preparedSkills.length)
@@ -1350,75 +1347,6 @@ class SkillService {
     this.scanLocalDir(this.storageDir, this.storageDir, skills);
   }
 
-  /**
-   * 合并平台原生安装目录中的技能，补齐“已安装但未被仓库/本地托管覆盖”的条目
-   */
-  mergeInstalledSkills(skills, options = {}) {
-    if (!fs.existsSync(this.installDir)) return;
-
-    const syncManagedLocalSkills = options.syncManagedLocalSkills === true;
-    const installedSkills = [];
-    this.scanInstalledDir(this.installDir, this.installDir, installedSkills);
-
-    for (const installedSkill of installedSkills) {
-      const normalizedDirectory = normalizeRepoPath(installedSkill.directory).toLowerCase();
-      const existing = skills.find(skill =>
-        normalizeRepoPath(skill.directory).toLowerCase() === normalizedDirectory
-      );
-
-      if (existing) {
-        const managedSkillMdPath = path.join(this.storageDir, installedSkill.directory, 'SKILL.md');
-        if (syncManagedLocalSkills && fs.existsSync(managedSkillMdPath)) {
-          const installedSkillPath = path.join(this.installDir, installedSkill.directory);
-          this.ensureManagedSkillCopy(installedSkill.directory, installedSkillPath, { overwrite: true });
-        }
-        existing.installed = true;
-        if (!existing.name && installedSkill.name) {
-          existing.name = installedSkill.name;
-        }
-        if (!existing.description && installedSkill.description) {
-          existing.description = installedSkill.description;
-        }
-        if (!existing.license && installedSkill.license) {
-          existing.license = installedSkill.license;
-        }
-        continue;
-      }
-
-      const installedSkillPath = path.join(this.installDir, installedSkill.directory);
-      this.ensureManagedSkillCopy(installedSkill.directory, installedSkillPath, {
-        overwrite: syncManagedLocalSkills
-      });
-      skills.push(installedSkill);
-    }
-  }
-
-  ensureManagedSkillCopy(directory, sourceDir, options = {}) {
-    const normalizedDirectory = normalizeRepoPath(directory);
-    const overwrite = options.overwrite === true;
-    if (!normalizedDirectory || !sourceDir || !fs.existsSync(sourceDir)) {
-      return false;
-    }
-
-    const sourceSkillMdPath = path.join(sourceDir, 'SKILL.md');
-    if (!fs.existsSync(sourceSkillMdPath)) {
-      return false;
-    }
-
-    const managedDir = path.join(this.storageDir, normalizedDirectory);
-    const managedSkillMdPath = path.join(managedDir, 'SKILL.md');
-    if (fs.existsSync(managedSkillMdPath)) {
-      if (!overwrite) {
-        return false;
-      }
-      fs.rmSync(managedDir, { recursive: true, force: true });
-    }
-
-    fs.mkdirSync(managedDir, { recursive: true });
-    this.copyDirRecursive(sourceDir, managedDir);
-    return true;
-  }
-
   /**
    * 递归扫描本地目录
    */
@@ -1482,54 +1410,6 @@ class SkillService {
     }
   }
 
-  /**
-   * 递归扫描平台原生安装目录
-   */
-  scanInstalledDir(currentDir, baseDir, skills) {
-    const skillMdPath = path.join(currentDir, 'SKILL.md');
-
-    if (fs.existsSync(skillMdPath)) {
-      const directory = currentDir === baseDir
-        ? path.basename(currentDir)
-        : path.relative(baseDir, currentDir);
-
-      try {
-        const content = fs.readFileSync(skillMdPath, 'utf-8');
-        const metadata = this.parseSkillMd(content);
-
-        skills.push({
-          key: `installed:${directory}`,
-          name: metadata.name || directory,
-          description: metadata.description || '',
-          directory,
-          installed: true,
-          isLocal: false,
-          readmeUrl: null,
-          repoOwner: null,
-          repoName: null,
-          repoBranch: null,
-          license: metadata.license,
-          source: 'native-installed'
-        });
-      } catch (err) {
-        console.warn(`[SkillService] Parse installed skill ${directory} error:`, err.message);
-      }
-
-      return;
-    }
-
-    try {
-      const entries = fs.readdirSync(currentDir, { withFileTypes: true });
-      for (const entry of entries) {
-        if (entry.isDirectory() && !entry.name.startsWith('.')) {
-          this.scanInstalledDir(path.join(currentDir, entry.name), baseDir, skills);
-        }
-      }
-    } catch (err) {
-      // 忽略读取错误
-    }
-  }
-
   /**
    * 去重技能列表
    */
@@ -2041,8 +1921,11 @@ ${content}
    * 获取技能详情（完整内容）
    */
   async getSkillDetail(directory, repoHint = null, fullDirectoryHint = '') {
-    const parseLocalSkillDetail = (skillMdPath, { installed, isLocal }) => {
-      const content = fs.readFileSync(skillMdPath, 'utf-8');
+    // 先检查本地是否安装
+    const localPath = path.join(this.installDir, directory, 'SKILL.md');
+
+    if (fs.existsSync(localPath)) {
+      const content = fs.readFileSync(localPath, 'utf-8');
       const metadata = this.parseSkillMd(content);
 
       // 提取正文内容（去除 frontmatter）
@@ -2055,29 +1938,9 @@ ${content}
         description: metadata.description || '',
         content: body,
         fullContent: content,
-        installed,
-        isLocal,
+        installed: true,
         source: 'local'
       };
-    };
-
-    // 先检查本地是否安装
-    const localPath = path.join(this.installDir, directory, 'SKILL.md');
-
-    if (fs.existsSync(localPath)) {
-      const managedSkillMdPath = path.join(this.storageDir, directory, 'SKILL.md');
-      return parseLocalSkillDetail(localPath, {
-        installed: true,
-        isLocal: fs.existsSync(managedSkillMdPath)
-      });
-    }
-
-    const managedLocalPath = path.join(this.storageDir, directory, 'SKILL.md');
-    if (fs.existsSync(managedLocalPath)) {
-      return parseLocalSkillDetail(managedLocalPath, {
-        installed: false,
-        isLocal: true
-      });
     }
 
     const parseRemoteSkillContent = (content, repo, fullDirectory = '') => {
@@ -2225,7 +2088,7 @@ ${content}
    */
   getInstalledSkills() {
     const skills = [];
-    this.scanInstalledDir(this.installDir, this.installDir, skills);
+    this.scanLocalDir(this.installDir, this.installDir, skills);
     return skills;
   }
 }