coding-tool-x 3.8.4 → 3.8.5

package/src/platforms/drivers/claude/session-history-adapter.js

@@ -0,0 +1,313 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const { NATIVE_PATHS } = require('../../../config/paths');
+
+const DEFAULT_CLAUDE_PROJECTS_DIR = NATIVE_PATHS?.claude?.projects || '';
+let claudeProjectsDir = DEFAULT_CLAUDE_PROJECTS_DIR;
+
+function configure({ pathContext } = {}) {
+  claudeProjectsDir = pathContext?.customized
+    ? (pathContext.native?.projects || DEFAULT_CLAUDE_PROJECTS_DIR)
+    : DEFAULT_CLAUDE_PROJECTS_DIR;
+}
+
+function _asContentBlocks(content) {
+  if (Array.isArray(content)) return content;
+  return content && typeof content === 'object' ? [content] : [];
+}
+
+function _formatJsonBlock(value, fallback = '') {
+  if (typeof value === 'string') return value;
+  try {
+    const serialized = JSON.stringify(value, null, 2);
+    return serialized === undefined ? fallback : serialized;
+  } catch (_) {
+    return fallback;
+  }
+}
+
+/**
+ * Get Claude user-visible text from a message content block.
+ * Shared with sessions.js API for display consistency.
+ */
+function getClaudeUserText(content) {
+  if (typeof content === 'string') {
+    return content === 'Warmup' ? '' : content;
+  }
+
+  const parts = [];
+  for (const item of _asContentBlocks(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 getClaudeToolResultText(content) {
+  const parts = [];
+  for (const item of _asContentBlocks(content)) {
+    if (item?.type !== 'tool_result') continue;
+    const resultContent = _formatJsonBlock(item.content, '');
+    if (resultContent) {
+      parts.push(`**[工具结果]**\n\`\`\`\n${resultContent}\n\`\`\``);
+    }
+  }
+  return parts.join('\n\n').trim();
+}
+
+function getClaudeAssistantText(content) {
+  if (typeof content === 'string') {
+    return content === 'Warmup' ? '' : content;
+  }
+
+  const parts = [];
+  let subtype = null;
+  for (const item of _asContentBlocks(content)) {
+    if (item?.type === 'text' && item.text) {
+      parts.push(item.text);
+    } else if (item?.type === 'image') {
+      parts.push('[图片]');
+    } else if (item?.type === 'tool_use') {
+      subtype = 'tool_use';
+      const input = _formatJsonBlock(item.input, '{}');
+      parts.push(`**[调用工具: ${item.name || 'unknown'}]**\n\`\`\`json\n${input}\n\`\`\``);
+    } else if (item?.type === 'tool_result') {
+      subtype = subtype || 'tool_result';
+      const resultContent = _formatJsonBlock(item.content, '');
+      if (resultContent) {
+        parts.push(`**[工具结果]**\n\`\`\`\n${resultContent}\n\`\`\``);
+      }
+    } else if (item?.type === 'thinking') {
+      subtype = subtype || 'thinking';
+      if (item.thinking) parts.push(`**[思考]**\n${item.thinking}`);
+    }
+  }
+
+  return { content: parts.join('\n\n').trim(), subtype };
+}
+
+/**
+ * Parse real project path from encoded name.
+ */
+function parseRealProjectPath(encodedName, config = {}) {
+  const { parseRealProjectPath: fn } = require('./sessions-implementation');
+  return fn(encodedName, config);
+}
+
+/**
+ * Inventory all Claude session files.
+ * @returns {Promise<Array<{filePath: string, size: number, mtimeMs: number, sessionId: string, projectHint: string}>>}
+ */
+async function inventory({ projectsDir } = {}) {
+  const descriptors = [];
+  const rootDir = projectsDir || claudeProjectsDir;
+
+  try {
+    await fs.promises.stat(rootDir);
+  } catch (_) {
+    return descriptors;
+  }
+
+  const projects = await fs.promises.readdir(rootDir, { withFileTypes: true });
+  for (const entry of projects) {
+    if (!entry.isDirectory()) continue;
+    const projectName = entry.name;
+    const projectPath = path.join(rootDir, projectName);
+
+    let files;
+    try {
+      files = await fs.promises.readdir(projectPath);
+    } catch (_) {
+      continue;
+    }
+
+    for (const f of files) {
+      if (!f.endsWith('.jsonl') || f.startsWith('agent-')) continue;
+      const filePath = path.join(projectPath, f);
+      let stat;
+      try {
+        stat = await fs.promises.stat(filePath);
+      } catch (_) {
+        continue;
+      }
+      descriptors.push({
+        filePath,
+        size: stat.size,
+        mtimeMs: stat.mtimeMs,
+        sessionId: f.replace(/\.jsonl$/, ''),
+        projectHint: projectName
+      });
+    }
+  }
+
+  return descriptors;
+}
+
+/**
+ * Parse a Claude session file into normalized session + messages.
+ * @param {{filePath: string, size: number, mtimeMs: number, sessionId: string, projectHint: string}} descriptor
+ * @returns {Promise<{session: object, messages: Array}>}
+ */
+async function parse(descriptor) {
+  const { filePath, size, mtimeMs, sessionId, projectHint } = descriptor;
+  const { fullPath, projectName: displayName } = parseRealProjectPath(projectHint, { projectsDir: descriptor.projectsDir });
+
+  const messages = [];
+  let firstMessage = null;
+  let gitBranch = null;
+  let provider = null;
+  let model = null;
+  let startedAt = null;
+  let updatedAt = null;
+  let usageJson = null;
+  const extra = {};
+  let userMessageNumber = 0;
+
+  const stream = fs.createReadStream(filePath, { encoding: 'utf8' });
+  const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+
+  for await (const line of rl) {
+    if (!line.trim()) continue;
+
+    let json;
+    try {
+      json = JSON.parse(line);
+    } catch (_) {
+      continue;
+    }
+
+    const messagePayload = json.message && typeof json.message === 'object' && !Array.isArray(json.message)
+      ? json.message
+      : {};
+    const recordTimestamp = json.timestamp || messagePayload.timestamp || null;
+    const timestampValue = recordTimestamp ? new Date(recordTimestamp).getTime() : null;
+    const timestamp = Number.isFinite(timestampValue) ? timestampValue : null;
+    const recordModel = json.model || messagePayload.model || null;
+    const recordProvider = json.provider || messagePayload.provider || null;
+    const recordUsage = json.usage || messagePayload.usage || null;
+
+    if (json.type === 'metadata' || json.type === 'summary') {
+      if (json.cwd || messagePayload.cwd) extra.cwd = json.cwd || messagePayload.cwd;
+      if (json.gitBranch || messagePayload.gitBranch) {
+        gitBranch = json.gitBranch || messagePayload.gitBranch;
+      }
+      if (json.summary) extra.summary = json.summary;
+      if (timestamp !== null && startedAt === null) startedAt = timestamp;
+      if (recordModel) model = recordModel;
+      if (recordProvider) provider = recordProvider;
+      if (recordUsage) usageJson = JSON.stringify(recordUsage);
+      continue;
+    }
+
+    const role = json.role
+      || messagePayload.role
+      || (json.type === 'user' || json.type === 'human'
+        ? 'user'
+        : json.type === 'assistant' || json.type === 'ai'
+          ? 'assistant'
+          : null);
+    if (role !== 'user' && role !== 'assistant') continue;
+
+    const rawContent = json.content !== undefined && json.content !== null && json.content !== ''
+      ? json.content
+      : messagePayload.content !== undefined
+        ? messagePayload.content
+        : typeof json.message === 'string' ? json.message : '';
+    const messageId = messagePayload.id || json.uuid || json.id || null;
+
+    if (timestamp !== null) {
+      if (startedAt === null) startedAt = timestamp;
+      updatedAt = timestamp;
+    }
+    if (recordModel) model = recordModel;
+    if (recordProvider) provider = recordProvider;
+    if (recordUsage) usageJson = JSON.stringify(recordUsage);
+
+    if (role === 'user') {
+      const content = getClaudeUserText(rawContent);
+      if (content) {
+        userMessageNumber++;
+        if (!firstMessage) firstMessage = content;
+        messages.push({
+          messageId,
+          role,
+          type: json.type || role,
+          subtype: null,
+          content,
+          timestamp,
+          model: recordModel || model || null,
+          provider: recordProvider || provider || null,
+          userMessageNumber,
+          extraJson: null
+        });
+      }
+
+      const toolResultContent = getClaudeToolResultText(rawContent);
+      if (toolResultContent) {
+        messages.push({
+          messageId: messageId ? `${messageId}-tool-result` : null,
+          role: 'assistant',
+          type: 'assistant',
+          subtype: 'tool_result',
+          content: toolResultContent,
+          timestamp,
+          model: recordModel || model || null,
+          provider: recordProvider || provider || null,
+          userMessageNumber: null,
+          extraJson: null
+        });
+      }
+      continue;
+    }
+
+    const assistant = getClaudeAssistantText(rawContent);
+    if (!assistant.content) continue;
+    messages.push({
+      messageId,
+      role,
+      type: json.type || role,
+      subtype: assistant.subtype,
+      content: assistant.content,
+      timestamp,
+      model: recordModel || model || null,
+      provider: recordProvider || provider || null,
+      userMessageNumber: null,
+      extraJson: null
+    });
+  }
+
+  rl.close();
+  stream.destroy();
+
+  const session = {
+    sessionId,
+    projectName: projectHint,
+    projectDisplayName: displayName,
+    projectFullPath: fullPath,
+    firstMessage: firstMessage || null,
+    gitBranch,
+    provider,
+    model,
+    startedAt,
+    updatedAt: updatedAt || mtimeMs,
+    usageJson,
+    extraJson: JSON.stringify(extra)
+  };
+
+  return {
+    session,
+    messages: messages.map((message) => ({
+      ...message,
+      extraJson: message.extraJson ? JSON.stringify(message.extraJson) : null
+    }))
+  };
+}
+
+module.exports = { configure, inventory, parse, getClaudeUserText };

package/src/{server/services/sessions.js → platforms/drivers/claude/sessions-implementation.js}

@@ -1,18 +1,41 @@
 const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
-const { getAllSessions, parseSessionInfoFast } = require('../../utils/session');
-const { loadAliases, setAlias } = require('./alias');
-const { globalCache, CacheKeys } = require('./enhanced-cache');
-const { listProjects: idxListProjects, listSessions: idxListSessions, getRecentSessions: idxGetRecent, searchSessions: idxSearch } = require('./session-history-index');
-const { PATHS, NATIVE_PATHS } = require('../../config/paths');
+const { spawnSync } = require('child_process');
+const { getAllSessions, parseSessionInfoFast } = require('../../../utils/session');
+const { loadAliases, setAlias } = require('../../../server/services/alias');
+const { globalCache, CacheKeys } = require('../../../server/services/enhanced-cache');
+let sessionHistoryIndex = null;
+
+function getSessionHistoryIndex(config = {}) {
+  if (!sessionHistoryIndex) {
+    const { getDefaultDependencies } = require('../../../platforms/runtime');
+    sessionHistoryIndex = getDefaultDependencies().sessionHistoryIndex;
+    if (!sessionHistoryIndex) {
+      const indexModule = require('../../../server/services/session-history-index');
+      sessionHistoryIndex = Object.keys(config).length > 0
+        ? indexModule.createSessionHistoryIndex({ config })
+        : indexModule;
+    }
+  }
+  return sessionHistoryIndex;
+}
+const { PATHS, NATIVE_PATHS } = require('../../../config/paths');
 
-const CLAUDE_PROJECTS_DIR = NATIVE_PATHS.claude.projects;
+const DEFAULT_CLAUDE_PROJECTS_DIR = NATIVE_PATHS.claude.projects;
 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');
+let claudeProjectsDir = DEFAULT_CLAUDE_PROJECTS_DIR;
+
+function configure({ sessionHistoryIndex: index, pathContext } = {}) {
+  sessionHistoryIndex = index || null;
+  claudeProjectsDir = pathContext?.customized
+    ? (pathContext.native?.projects || DEFAULT_CLAUDE_PROJECTS_DIR)
+    : DEFAULT_CLAUDE_PROJECTS_DIR;
+}
 
 function resolveProjectsDir(config = {}) {
-  return config.projectsDir || CLAUDE_PROJECTS_DIR;
+  return config.projectsDir || claudeProjectsDir;
 }
 
 function withResolvedProjectsDir(config = {}) {
@@ -24,6 +47,81 @@ function getOrderFilePath() { return PATHS.projectOrder; }
 function getForkRelationsFilePath() { return PATHS.forkRelations; }
 function getSessionOrderFilePath() { return PATHS.sessionOrder; }
 
+function readSessionCwd(config = {}, sessionId) {
+  const sessionFile = path.join(
+    resolveProjectsDir(config),
+    config.currentProject || '',
+    `${sessionId}.jsonl`
+  );
+  let fd;
+  try {
+    fd = fs.openSync(sessionFile, 'r');
+    const buffer = Buffer.alloc(2048);
+    const bytesRead = fs.readSync(fd, buffer, 0, buffer.length, 0);
+    const lines = buffer.subarray(0, bytesRead).toString('utf8').split('\n').slice(0, 5);
+    for (const line of lines) {
+      try {
+        const value = JSON.parse(line);
+        if (typeof value.cwd === 'string' && value.cwd.trim()) return value.cwd;
+      } catch (_) {
+        // 忽略无效的会话元数据
+      }
+    }
+  } catch (_) {
+    return null;
+  } finally {
+    if (fd !== undefined) {
+      try {
+        fs.closeSync(fd);
+      } catch (_) {
+        // 忽略文件关闭错误
+      }
+    }
+  }
+  return null;
+}
+
+function resolveLaunchCwd(config, sessionId, cwd) {
+  const candidate = typeof cwd === 'string' && cwd.trim()
+    ? cwd
+    : readSessionCwd(config, sessionId);
+  if (candidate) {
+    try {
+      if (fs.statSync(candidate).isDirectory()) return candidate;
+    } catch (_) {
+      // 使用当前目录
+    }
+  }
+  return process.cwd();
+}
+
+function launch(sessionId, {
+  fork = false,
+  config = {},
+  cwd,
+  processRunner = spawnSync
+} = {}) {
+  const normalizedSessionId = String(sessionId || '');
+  const args = ['-r', normalizedSessionId];
+  if (fork) args.push('--fork-session');
+  const launchCwd = resolveLaunchCwd(config, normalizedSessionId, cwd);
+  const result = processRunner('claude', args, {
+    cwd: launchCwd,
+    stdio: 'inherit',
+    windowsHide: true
+  });
+  if (result?.error) {
+    throw result.error instanceof Error ? result.error : new Error(String(result.error));
+  }
+  return {
+    ...(result && typeof result === 'object' ? result : {}),
+    status: result?.status ?? 0,
+    signal: result?.signal || null,
+    cwd: launchCwd,
+    args
+  };
+}
+
 function getProjectOrder(config) {
   const orderFile = getOrderFilePath();
   try { if (fs.existsSync(orderFile)) return JSON.parse(fs.readFileSync(orderFile, 'utf8')); } catch (_) {}
@@ -101,20 +199,20 @@ function sliceClaudeSessionContentByUserMessage(content, afterUserMessageNumber)
 
 // ===== Read-side: all project/list/session/recent/search delegate to session-history-index =====
 
-async function getProjects(config) {
-  const indexed = await idxListProjects('claude');
+async function getProjects(config = {}, options = {}) {
+  const indexed = await getSessionHistoryIndex(config).listProjects('claude', { ...options, config });
   return indexed.map(p => p.name);
 }
 
-async function getProjectsWithStats(config, options = {}) {
-  return idxListProjects('claude');
+async function getProjectsWithStats(config = {}, options = {}) {
+  return getSessionHistoryIndex(config).listProjects('claude', { ...options, config });
 }
 
 // ===== Path resolution helpers (kept for mutation/conversion paths) =====
 
-function parseRealProjectPath(encodedName) {
+function parseRealProjectPath(encodedName, config = {}) {
   const isWindows = process.platform === 'win32';
-  const fallbackFromSessions = tryResolvePathFromSessions(encodedName);
+  const fallbackFromSessions = tryResolvePathFromSessions(encodedName, config);
   const windowsDriveMatch = encodedName.match(/^([A-Z])--(.+)$/);
 
   if (isWindows && windowsDriveMatch) {
@@ -197,9 +295,9 @@ function validateProjectPath(candidatePath) {
   return (candidatePath && fs.existsSync(candidatePath)) ? candidatePath : null;
 }
 
-function tryResolvePathFromSessions(encodedName) {
+function tryResolvePathFromSessions(encodedName, config = {}) {
   try {
-    const projectDir = path.join(CLAUDE_PROJECTS_DIR, encodedName);
+    const projectDir = path.join(resolveProjectsDir(config), encodedName);
     if (!fs.existsSync(projectDir)) return null;
     const files = fs.readdirSync(projectDir).filter(f => f.endsWith('.jsonl'));
     for (const file of files) {
@@ -228,24 +326,19 @@ function extractCwdFromSessionHeader(sessionFile) {
 
 // ===== Counts: delegates to index =====
 
-async function getProjectAndSessionCounts(config) {
-  try {
-    const projects = await idxListProjects('claude');
-    let sessionCount = 0;
-    for (const p of projects) sessionCount += p.sessionCount || 0;
-    return { projectCount: projects.length, sessionCount };
-  } catch (_) {
-    return { projectCount: 0, sessionCount: 0 };
-  }
+async function getProjectAndSessionCounts(config = {}, options = {}) {
+  const projects = await getSessionHistoryIndex().listProjects('claude', { ...options, config });
+  let sessionCount = 0;
+  for (const project of projects) sessionCount += project.sessionCount || 0;
+  return { projectCount: projects.length, sessionCount };
 }
 
 // ===== Sessions for project: index + saved order + fork relations =====
 
 async function getSessionsForProject(config, projectName, options = {}) {
-  const indexed = await idxListSessions('claude', projectName);
+  const indexed = await getSessionHistoryIndex().listSessions('claude', projectName, { ...options, config });
   const forkRelations = getForkRelations();
   const savedOrder = getSessionOrder(projectName);
-
   let sessions = indexed.map(s => ({
     sessionId: s.sessionId,
     mtime: s.mtime,
@@ -269,7 +362,6 @@ async function getSessionsForProject(config, projectName, options = {}) {
   const totalSize = sessions.reduce((sum, s) => sum + (s.size || 0), 0);
   return { sessions, totalSize };
 }
-
 // ===== Mutations (sync) =====
 
 function deleteSession(config, projectName, sessionId) {
@@ -343,8 +435,8 @@ function deleteProject(config, projectName) {
 
 // ===== Search: delegates to index =====
 
-async function searchSessions(config, projectName, keyword, contextLength = 15) {
-  const results = await idxSearch('claude', keyword, { projectName, contextLength });
+async function searchSessions(config, projectName, keyword, contextLength = 15, options = {}) {
+  const results = await getSessionHistoryIndex().searchSessions('claude', keyword, { projectName, contextLength, ...options, config });
   const aliases = loadAliases();
   return results.map(r => ({
     sessionId: r.sessionId,
@@ -354,10 +446,10 @@ async function searchSessions(config, projectName, keyword, contextLength = 15)
   }));
 }
 
-async function getRecentSessions(config, limit = 5) {
-  const indexed = await idxGetRecent('claude', limit);
-  const aliases = loadAliases();
+async function getRecentSessions(config, limit = 5, options = {}) {
+  const indexed = await getSessionHistoryIndex().getRecentSessions('claude', limit, { ...options, config });
   const forkRelations = getForkRelations();
+  const aliases = loadAliases();
   return indexed.map(s => ({
     sessionId: s.sessionId,
     projectName: s.projectName,
@@ -377,13 +469,13 @@ async function searchSessionsAcrossProjects(config, keyword, contextLength = 35)
   const allResults = [];
 
   try {
-    const claudeResults = await idxSearch('claude', keyword, { contextLength });
+    const claudeResults = await getSessionHistoryIndex().searchSessions('claude', keyword, { contextLength });
     for (const r of claudeResults) allResults.push({ ...r, channel: 'claude' });
   } catch (_) {}
 
   try {
     if (fs.existsSync(CODEX_PROJECTS_DIR)) {
-      const { searchSessions: codexSearch } = require('./codex-sessions');
+      const { searchSessions: codexSearch } = require('../codex/sessions-implementation');
       const codexResults = await codexSearch(keyword);
       for (const r of codexResults) allResults.push({ ...r, channel: 'codex' });
     }
@@ -391,7 +483,7 @@ async function searchSessionsAcrossProjects(config, keyword, contextLength = 35)
 
   try {
     if (fs.existsSync(GEMINI_PROJECTS_DIR)) {
-      const { searchSessions: geminiSearch } = require('./gemini-sessions');
+      const { searchSessions: geminiSearch } = require('../gemini/sessions-implementation');
       const geminiResults = await geminiSearch(keyword, contextLength);
       for (const r of geminiResults) allResults.push({ ...r, channel: 'gemini' });
     }
@@ -400,13 +492,31 @@ async function searchSessionsAcrossProjects(config, keyword, contextLength = 35)
   allResults.sort((a, b) => (b.matchCount || 0) - (a.matchCount || 0));
   return allResults;
 }
+function hasActualMessages(sessionFile) {
+  if (!sessionFile || !fs.existsSync(sessionFile)) return false;
+  return fs.readFileSync(sessionFile, 'utf8')
+    .split(/\r?\n/)
+    .some(line => {
+      if (!line.trim()) return false;
+      try {
+        const entry = JSON.parse(line);
+        return entry.type === 'user' || entry.type === 'assistant'
+          || entry.message?.role === 'user' || entry.message?.role === 'assistant';
+      } catch (_) {
+        return false;
+      }
+    });
+}
+
 
 module.exports = {
+  configure,
   getProjects,
   getProjectsWithStats,
   getSessionsForProject,
   deleteSession,
   forkSession,
+  launch,
   getRecentSessions,
   getProjectOrder,
   saveProjectOrder,

package/src/platforms/drivers/claude/sessions.js

@@ -0,0 +1,76 @@
+'use strict';
+
+const { createCapabilityDriver } = require('../../../shared/capability-driver');
+
+function createDriver(context = {}) {
+  return createCapabilityDriver({
+    ...context,
+    platform: 'claude',
+    capability: 'sessions',
+    parserVersion: 2,
+    servicePath: './claude/sessions-implementation',
+    localServicePath: '../platforms/drivers/claude/sessions-implementation',
+    adapterLocalPath: '../platforms/drivers/claude/session-history-adapter',
+    adapterMethods: { inventory: 'inventory', parse: 'parse' },
+    methods: {
+      launch: 'launch',
+      saveSessionOrder: 'saveSessionOrder',
+      getSessionOrder: 'getSessionOrder',
+      parseRealProjectPath: 'parseRealProjectPath',
+      hasActualMessages: 'hasActualMessages',
+      status: 'getSessionStatus',
+      messages: 'getSessionMessages'
+    },
+    customMethods: {
+      delete: (service, projectName, sessionId, options = {}) => {
+        const result = service.deleteSession(options.config || {}, projectName, sessionId);
+        context.sessionHistoryIndex?.invalidateSource('claude');
+        return result;
+      },
+      fork: (service, projectName, sessionId, options = {}) => {
+        const result = service.forkSession(options.config || {}, projectName, sessionId, options);
+        context.sessionHistoryIndex?.invalidateSource('claude');
+        return result;
+      },
+      listSessions: (service, projectNameOrRequest, options = {}) => {
+        const descriptorRequest = projectNameOrRequest && typeof projectNameOrRequest === 'object';
+        const request = descriptorRequest ? projectNameOrRequest : options;
+        const projectName = descriptorRequest
+          ? request.params?.projectName
+          : projectNameOrRequest;
+        return service.getSessionsForProject(
+          request.config || {},
+          projectName,
+          request
+        );
+      },
+      recent: (service, limitOrRequest, options = {}) => {
+        const descriptorRequest = limitOrRequest && typeof limitOrRequest === 'object';
+        const request = descriptorRequest ? limitOrRequest : options;
+        const limit = descriptorRequest
+          ? Number.parseInt(request.query?.limit, 10) || 5
+          : limitOrRequest;
+        return service.getRecentSessions(request.config || {}, limit, request);
+      },
+      search: (service, projectName, keyword, contextLength, options = {}) => service.searchSessions(
+        options.config || {},
+        projectName,
+        keyword,
+        contextLength,
+        options
+      ),
+      searchAcrossProjects: (service, keyword, limit, options = {}) => service.searchSessionsAcrossProjects(
+        options.config || {},
+        keyword,
+        limit
+      )
+    },
+    onSuccess: operation => {
+      if (['delete', 'fork', 'saveSessionOrder'].includes(operation)) {
+        context.sessionHistoryIndex?.invalidateSource('claude');
+      }
+    }
+  });
+}
+
+module.exports = { createDriver };

package/src/{server/services/claude-statistics-service.js → platforms/drivers/claude/statistics-implementation.js}

@@ -3,8 +3,8 @@ const {
   getStatistics: getSharedStatistics,
   getDailyStatistics: getSharedDailyStatistics,
   getTodayStatistics: getSharedTodayStatistics
-} = require('./statistics-service');
-const { normalizeUsageTokens, toNumber } = require('./proxy-log-helper');
+} = require('../../../server/services/statistics-service');
+const { normalizeUsageTokens, toNumber } = require('../../../server/services/usage-log-utils');
 
 const TOOL_TYPE = 'claude-code';
 const USAGE_SOURCE = 'claude';