coding-tool-x 3.5.9 → 3.5.11

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,34 +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();
-
-function getProjectsStatsCacheKey(config) {
-  return `${CacheKeys.PROJECTS}${config?.projectsDir || '__default__'}`;
-}
-
-function getProjectSessionsCacheKey(projectName) {
-  return `${CacheKeys.SESSIONS}${projectName}`;
-}
-
-function invalidateProjectStatsCache(config) {
-  invalidateProjectsCache(config);
-  globalCache.delete(getProjectsStatsCacheKey(config));
-}
-
-function invalidateProjectSessionCache(projectName) {
-  if (!projectName) return;
-  globalCache.delete(getProjectSessionsCacheKey(projectName));
-}
-
-function invalidateProjectCaches(config, projectName) {
-  invalidateProjectStatsCache(config);
-  invalidateProjectSessionCache(projectName);
-}
+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() {
@@ -112,96 +86,123 @@ 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 '';
+  }
+
+  const parts = [];
+  for (const item of content) {
+    if (item?.type === 'text' && item.text) {
+      parts.push(item.text);
+    } else if (item?.type === 'image') {
+      parts.push('[图片]');
+    }
+  }
 
-function getProjectPathCacheKey(encodedName) {
-  return `${process.platform}:${encodedName}`;
+  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;
+  let targetUserReached = false;
 
-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;
+    }
 
-  while (projectPathResolutionCache.size > MAX_PROJECT_PATH_CACHE_ENTRIES) {
-    const oldestKey = projectPathResolutionCache.keys().next().value;
-    if (!oldestKey) {
-      break;
+    if (json.type !== 'user') {
+      keptLines.push(line);
+      continue;
     }
-    projectPathResolutionCache.delete(oldestKey);
+
+    const userText = getClaudeForkMessageText(json.message?.content);
+    if (!userText) {
+      keptLines.push(line);
+      continue;
+    }
+
+    if (targetUserReached) {
+      return joinTextPreserveEol(keptLines, eol, hasTrailingEol);
+    }
+
+    matchedUserMessages += 1;
+    keptLines.push(line);
+    if (matchedUserMessages >= afterUserMessageNumber) {
+      targetUserReached = true;
+    }
+  }
+
+  if (targetUserReached) {
+    return joinTextPreserveEol(keptLines, eol, hasTrailingEol);
   }
+
+  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
@@ -260,15 +261,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
@@ -320,12 +319,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;
   }
 }
 
@@ -336,41 +333,6 @@ function validateProjectPath(candidatePath) {
   return null;
 }
 
-function scanSessionsDir(sessionsDir) {
-  if (!sessionsDir || !fs.existsSync(sessionsDir)) {
-    return [];
-  }
-
-  return fs.readdirSync(sessionsDir)
-    .filter(file => file.endsWith('.jsonl') && !file.startsWith('agent-'))
-    .map((file) => {
-      const filePath = path.join(sessionsDir, file);
-      const stats = fs.statSync(filePath);
-      return {
-        sessionId: file.replace('.jsonl', ''),
-        filePath,
-        size: stats.size,
-        mtime: stats.mtime
-      };
-    });
-}
-
-function getProjectSessionsDir(config, projectName) {
-  return path.join(config.projectsDir, projectName);
-}
-
-function getProjectSessionFiles(config, projectName) {
-  return scanSessionsDir(getProjectSessionsDir(config, projectName)).sort((a, b) => b.mtime - a.mtime);
-}
-
-function resolveSessionFile(config, projectName, sessionId) {
-  const sessionFile = path.join(getProjectSessionsDir(config, projectName), `${sessionId}.jsonl`);
-  if (fs.existsSync(sessionFile)) {
-    return sessionFile;
-  }
-  return '';
-}
-
 function tryResolvePathFromSessions(encodedName) {
   try {
     const projectDir = path.join(CLAUDE_PROJECTS_DIR, encodedName);
@@ -423,7 +385,7 @@ function extractCwdFromSessionHeader(sessionFile) {
 async function getProjectsWithStats(config, options = {}) {
   if (!options.force) {
     // Check enhanced cache first
-    const cacheKey = getProjectsStatsCacheKey(config);
+    const cacheKey = `${CacheKeys.PROJECTS}${config.projectsDir}`;
     const enhancedCached = globalCache.get(cacheKey);
     if (enhancedCached) {
       return enhancedCached;
@@ -444,7 +406,7 @@ async function getProjectsWithStats(config, options = {}) {
       return [];
     }
     setCachedProjects(config, data);
-    globalCache.set(getProjectsStatsCacheKey(config), data, 300000);
+    globalCache.set(`${CacheKeys.PROJECTS}${config.projectsDir}`, data, 300000);
     return data;
   } catch (err) {
     console.error(`[getProjectsWithStats] Failed to build projects for ${config.projectsDir}:`, err);
@@ -476,19 +438,30 @@ async function buildProjectsWithStats(config) {
       let lastUsed = null;
 
       try {
+        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(
-          getProjectSessionFiles(config, projectName).map(async (session) => {
-            const stats = await fs.promises.stat(session.filePath);
-            const hasMessages = await hasActualMessages(session.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
@@ -523,8 +496,10 @@ function getProjectAndSessionCounts(config) {
       return;
     }
     projectCount += 1;
+    const projectPath = path.join(projectsDir, entry.name);
     try {
-      sessionCount += getProjectSessionFiles(config, entry.name).length;
+      const files = fs.readdirSync(projectPath);
+      sessionCount += files.filter(file => file.endsWith('.jsonl') && !file.startsWith('agent-')).length;
     } catch (err) {
       // 忽略单个项目的读取错误
     }
@@ -534,9 +509,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()}`;
@@ -627,14 +602,14 @@ function scanSessionFileForMessagesAsync(filePath) {
 // Get sessions for a project - async version
 async function getSessionsForProject(config, projectName) {
   // Check cache first
-  const cacheKey = getProjectSessionsCacheKey(projectName);
+  const cacheKey = `${CacheKeys.SESSIONS}${projectName}`;
   const cached = globalCache.get(cacheKey);
   if (cached) {
     return cached;
   }
 
   const projectConfig = { ...config, currentProject: projectName };
-  const sessions = getProjectSessionFiles(projectConfig, projectName);
+  const sessions = getAllSessions(projectConfig);
   const forkRelations = getForkRelations();
   const savedOrder = getSessionOrder(projectName);
 
@@ -679,10 +654,8 @@ async function getSessionsForProject(config, projectName) {
     }
 
     // Add remaining sessions (new ones not in saved order)
-    const newSessions = [...sessionMap.values()].sort((a, b) => {
-      return new Date(b.mtime).getTime() - new Date(a.mtime).getTime();
-    });
-    orderedSessions = [...newSessions, ...ordered];
+    ordered.push(...sessionMap.values());
+    orderedSessions = ordered;
   }
 
   const result = {
@@ -697,31 +670,38 @@ async function getSessionsForProject(config, projectName) {
 
 // Delete a session
 function deleteSession(config, projectName, sessionId) {
-  const sessionFile = resolveSessionFile(config, projectName, sessionId);
+  const projectDir = path.join(config.projectsDir, projectName);
+  const sessionFile = path.join(projectDir, sessionId + '.jsonl');
 
-  if (!sessionFile || !fs.existsSync(sessionFile)) {
+  if (!fs.existsSync(sessionFile)) {
     throw new Error('Session not found');
   }
 
   fs.unlinkSync(sessionFile);
-  invalidateProjectCaches(config, projectName);
+  invalidateProjectsCache(config);
+  invalidateSessionResultCache(projectName);
   return { success: true };
 }
 
 // Fork a session
-function forkSession(config, projectName, sessionId) {
-  const sessionFile = resolveSessionFile(config, projectName, sessionId);
+function forkSession(config, projectName, sessionId, options = {}) {
+  const projectDir = path.join(config.projectsDir, projectName);
+  const sessionFile = path.join(projectDir, sessionId + '.jsonl');
 
-  if (!sessionFile || !fs.existsSync(sessionFile)) {
+  if (!fs.existsSync(sessionFile)) {
     throw new Error('Session not found');
   }
 
   // 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();
-  const newSessionFile = path.join(path.dirname(sessionFile), newSessionId + '.jsonl');
+  const newSessionFile = path.join(projectDir, newSessionId + '.jsonl');
 
   // Write to new file
   fs.writeFileSync(newSessionFile, content, 'utf8');
@@ -730,15 +710,19 @@ function forkSession(config, projectName, sessionId) {
   const forkRelations = getForkRelations();
   forkRelations[newSessionId] = sessionId;
   saveForkRelations(forkRelations);
-
-  const savedOrder = getSessionOrder(projectName);
-  if (savedOrder.length > 0) {
-    saveSessionOrder(projectName, [newSessionId, ...savedOrder.filter(id => id !== newSessionId)]);
+  if (options.alias) {
+    const { setAlias } = require('./alias');
+    setAlias(newSessionId, options.alias);
   }
+  invalidateProjectsCache(config);
+  invalidateSessionResultCache(projectName);
 
-  invalidateProjectCaches(config, projectName);
-
-  return { newSessionId, forkedFrom: sessionId };
+  return {
+    newSessionId,
+    forkedFrom: sessionId,
+    alias: options.alias || null,
+    afterUserMessageNumber: options.afterUserMessageNumber || null
+  };
 }
 
 // Get session order for a project
@@ -778,19 +762,19 @@ function saveSessionOrder(projectName, order) {
   // Update order for this project
   allOrders[projectName] = order;
   fs.writeFileSync(orderFile, JSON.stringify(allOrders, null, 2), 'utf8');
-  invalidateProjectSessionCache(projectName);
 }
 
 // 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);
@@ -798,22 +782,26 @@ function deleteProject(config, projectName) {
     saveProjectOrder(config, newOrder);
   }
 
-  invalidateProjectCaches(config, projectName);
-  clearProjectPathResolutionCache(projectName);
-  return {
-    success: true,
-    alreadyDeleted: !existed
-  };
+  invalidateProjectsCache(config);
+  return { success: true };
 }
 
 // Search sessions for keyword
 function searchSessions(config, projectName, keyword, contextLength = 15) {
+  const projectDir = path.join(config.projectsDir, projectName);
+
+  if (!fs.existsSync(projectDir)) {
+    return [];
+  }
+
   const results = [];
+  const files = fs.readdirSync(projectDir);
+  const jsonlFiles = files.filter(f => f.endsWith('.jsonl') && !f.startsWith('agent-'));
   const aliases = loadAliases();
 
-  for (const session of getProjectSessionFiles(config, projectName)) {
-    const sessionId = session.sessionId;
-    const filePath = session.filePath;
+  for (const file of jsonlFiles) {
+    const sessionId = file.replace('.jsonl', '');
+    const filePath = path.join(projectDir, file);
 
     // Skip sessions with no actual messages
     if (!hasActualMessages(filePath)) {
@@ -887,7 +875,7 @@ async function getRecentSessions(config, limit = 5) {
   // Collect all sessions from all projects
   projects.forEach(projectName => {
     const projectConfig = { ...config, currentProject: projectName };
-    const sessions = getProjectSessionFiles(projectConfig, projectName);
+    const sessions = getAllSessions(projectConfig);
     const { projectName: displayName, fullPath } = parseRealProjectPath(projectName);
 
     sessions.forEach(session => {