coding-tool-x 3.8.6 → 3.8.8

package/src/platforms/drivers/dsh/statistics-implementation.js

@@ -0,0 +1,238 @@
+'use strict';
+
+const {
+  recordRequest: recordSharedRequest,
+  getStatistics: getSharedStatistics,
+  getDailyStatistics: getSharedDailyStatistics,
+  getTodayStatistics: getSharedTodayStatistics
+} = require('../../../server/services/statistics-service');
+const { normalizeUsageTokens, toNumber } = require('../../../server/services/usage-log-utils');
+const { listArtifacts } = require('./sessions');
+const { normalizeDshEvent } = require('./native-logs');
+
+const TOOL_TYPE = 'dsh';
+let configuredContext = {};
+
+function configure(context = {}) {
+  configuredContext = context;
+}
+
+function initAggregateEntry(name = '') {
+  return {
+    name,
+    requests: 0,
+    tokens: { input: 0, output: 0, reasoning: 0, cached: 0, total: 0 },
+    cost: 0,
+    firstUsed: null,
+    lastUsed: null
+  };
+}
+
+function toLegacyEntryShape(entry = {}, includeName = false) {
+  const normalized = normalizeUsageTokens(TOOL_TYPE, entry.tokens || {});
+  const result = {
+    requests: toNumber(entry.requests),
+    tokens: {
+      input: normalized.input,
+      output: normalized.output,
+      reasoning: normalized.reasoning,
+      cached: normalized.cached,
+      total: normalized.total
+    },
+    cost: toNumber(entry.cost)
+  };
+
+  if (includeName) {
+    result.name = entry.name || '';
+    if (entry.firstUsed) result.firstUsed = entry.firstUsed;
+    if (entry.lastUsed) result.lastUsed = entry.lastUsed;
+  }
+  return result;
+}
+
+function pickToolScope(sharedStats = {}) {
+  const byToolType = sharedStats.byToolType || {};
+  const toolScope = byToolType[TOOL_TYPE] || {};
+  const byChannel = toolScope.channels && typeof toolScope.channels === 'object'
+    ? toolScope.channels
+    : Object.fromEntries(Object.entries(sharedStats.byChannel || {}).filter(([, value]) => value?.toolType === TOOL_TYPE));
+  const byModel = toolScope.models && typeof toolScope.models === 'object'
+    ? toolScope.models
+    : Object.fromEntries(Object.entries(sharedStats.byModel || {}).filter(([, value]) => value?.toolType === TOOL_TYPE));
+  return { toolScope, byChannel, byModel };
+}
+
+function buildSummaryStatistics(sharedStats = {}) {
+  const { toolScope, byChannel, byModel } = pickToolScope(sharedStats);
+  const normalized = toLegacyEntryShape(toolScope);
+  return {
+    version: '1.0',
+    source: 'shared-stats',
+    lastUpdated: sharedStats.lastUpdated || new Date().toISOString(),
+    global: {
+      totalRequests: normalized.requests,
+      totalTokens: normalized.tokens.total,
+      totalCost: normalized.cost
+    },
+    byChannel: Object.fromEntries(Object.entries(byChannel).map(([key, value]) => [key, toLegacyEntryShape(value, true)])),
+    byModel: Object.fromEntries(Object.entries(byModel).map(([key, value]) => [key, toLegacyEntryShape(value)]))
+  };
+}
+
+function buildDailyStatistics(sharedDaily = {}, fallbackDate) {
+  const toolScope = sharedDaily.byToolType?.[TOOL_TYPE] || {};
+  const normalized = toLegacyEntryShape(toolScope);
+  return {
+    date: sharedDaily.date || fallbackDate,
+    source: 'shared-stats',
+    summary: {
+      requests: normalized.requests,
+      tokens: normalized.tokens.total,
+      cost: normalized.cost
+    },
+    byChannel: Object.fromEntries(Object.entries(toolScope.channels || {}).map(([key, value]) => [key, toLegacyEntryShape(value, true)])),
+    byModel: Object.fromEntries(Object.entries(toolScope.models || {}).map(([key, value]) => [key, toLegacyEntryShape(value)]))
+  };
+}
+
+function hasSummaryData(summary = {}) {
+  return Boolean(
+    summary.global?.totalRequests
+    || summary.global?.totalTokens
+    || summary.global?.totalCost
+    || Object.keys(summary.byChannel || {}).length
+    || Object.keys(summary.byModel || {}).length
+  );
+}
+
+function hasDailyData(daily = {}) {
+  return Boolean(
+    daily.summary?.requests
+    || daily.summary?.tokens
+    || daily.summary?.cost
+    || Object.keys(daily.byChannel || {}).length
+    || Object.keys(daily.byModel || {}).length
+  );
+}
+
+function eventDateKey(timestamp) {
+  const date = new Date(timestamp);
+  if (Number.isNaN(date.getTime())) return null;
+  return new Date(date.getTime() + 8 * 60 * 60 * 1000).toISOString().slice(0, 10);
+}
+
+function resolveDate(value) {
+  if (value && typeof value === 'object') {
+    return value.params?.date || value.query?.date || eventDateKey(Date.now());
+  }
+  return value || eventDateKey(Date.now());
+}
+
+function readSessionUsage() {
+  try {
+    const artifacts = listArtifacts(configuredContext, { includeEvents: true });
+    return artifacts.flatMap(artifact => (artifact.events || [])
+      .map((event, index) => normalizeDshEvent(event, artifact.filePath, index))
+      .filter(Boolean)
+      .map(event => ({ ...event, sessionId: artifact.header?.id || event.sessionId })));
+  } catch (_) {
+    return [];
+  }
+}
+
+function addUsage(entry, event) {
+  const tokens = normalizeUsageTokens(TOOL_TYPE, event.tokens || {});
+  if (!tokens.total && !tokens.input && !tokens.output && !tokens.reasoning && !tokens.cached) return false;
+  entry.requests += 1;
+  entry.tokens.input += tokens.input;
+  entry.tokens.output += tokens.output;
+  entry.tokens.reasoning += tokens.reasoning;
+  entry.tokens.cached += tokens.cached;
+  entry.tokens.total += tokens.total;
+  entry.cost += toNumber(event.cost);
+  const iso = new Date(event.timestamp).toISOString();
+  if (!entry.firstUsed || iso < entry.firstUsed) entry.firstUsed = iso;
+  if (!entry.lastUsed || iso > entry.lastUsed) entry.lastUsed = iso;
+  return true;
+}
+
+function buildSessionDerivedStatistics(events = readSessionUsage()) {
+  const global = initAggregateEntry('DSH Sessions');
+  const byChannel = {};
+  const byModel = {};
+  events.forEach(event => {
+    if (!addUsage(global, event)) return;
+    const channel = event.channel || event.provider || 'dsh-session';
+    const model = event.model || 'unknown';
+    byChannel[channel] ||= initAggregateEntry(channel || 'DSH Session');
+    byModel[model] ||= initAggregateEntry(model);
+    addUsage(byChannel[channel], event);
+    addUsage(byModel[model], event);
+  });
+  return {
+    version: '1.0',
+    source: global.requests ? 'sessions' : 'empty',
+    lastUpdated: global.lastUsed || new Date().toISOString(),
+    global: { totalRequests: global.requests, totalTokens: global.tokens.total, totalCost: global.cost },
+    byChannel: Object.fromEntries(Object.entries(byChannel).map(([key, value]) => [key, toLegacyEntryShape(value, true)])),
+    byModel: Object.fromEntries(Object.entries(byModel).map(([key, value]) => [key, toLegacyEntryShape(value)]))
+  };
+}
+
+function buildSessionDerivedDailyStatistics(date, events = readSessionUsage()) {
+  const daily = buildSessionDerivedStatistics(events.filter(event => eventDateKey(event.timestamp) === date));
+  return {
+    date,
+    source: daily.source,
+    summary: {
+      requests: daily.global.totalRequests,
+      tokens: daily.global.totalTokens,
+      cost: daily.global.totalCost
+    },
+    byChannel: daily.byChannel,
+    byModel: daily.byModel
+  };
+}
+
+function recordRequest(requestData = {}) {
+  const normalizedTokens = normalizeUsageTokens(TOOL_TYPE, requestData.tokens || {});
+  return recordSharedRequest({
+    ...requestData,
+    toolType: TOOL_TYPE,
+    tokens: {
+      input: normalizedTokens.input,
+      output: normalizedTokens.output,
+      reasoning: normalizedTokens.reasoning,
+      cached: normalizedTokens.cached,
+      cacheCreation: normalizedTokens.cacheCreation,
+      cacheRead: normalizedTokens.cacheRead,
+      total: normalizedTokens.total
+    }
+  });
+}
+
+function getStatistics() {
+  const shared = buildSummaryStatistics(getSharedStatistics());
+  return hasSummaryData(shared) ? shared : buildSessionDerivedStatistics();
+}
+
+function getDailyStatistics(date) {
+  const requestedDate = resolveDate(date);
+  const shared = buildDailyStatistics(getSharedDailyStatistics(requestedDate), requestedDate);
+  return hasDailyData(shared) ? shared : buildSessionDerivedDailyStatistics(requestedDate);
+}
+
+function getTodayStatistics() {
+  const shared = buildDailyStatistics(getSharedTodayStatistics());
+  const date = shared.date || eventDateKey(Date.now());
+  return hasDailyData(shared) ? shared : buildSessionDerivedDailyStatistics(date);
+}
+
+module.exports = {
+  configure,
+  recordRequest,
+  getStatistics,
+  getDailyStatistics,
+  getTodayStatistics,
+  _test: { buildSessionDerivedStatistics, buildSessionDerivedDailyStatistics }
+};

package/src/platforms/drivers/dsh/statistics.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const { createCapabilityDriver } = require('../../../shared/capability-driver');
+
+function createDriver(context = {}) {
+  return createCapabilityDriver({
+    ...context,
+    platform: 'dsh',
+    capability: 'statistics',
+    servicePath: './dsh/statistics-implementation',
+    localServicePath: '../platforms/drivers/dsh/statistics-implementation',
+    methods: {
+      summary: 'getStatistics',
+      daily: 'getDailyStatistics',
+      today: 'getTodayStatistics',
+      getStatistics: 'getStatistics',
+      getDailyStatistics: 'getDailyStatistics',
+      getTodayStatistics: 'getTodayStatistics',
+      recordRequest: 'recordRequest'
+    }
+  });
+}
+
+module.exports = { createDriver };

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

@@ -298,6 +298,54 @@ async function inventory() {
   return descriptors;
 }
 
+async function summarize(descriptor) {
+  const header = readDescriptorMetadata(descriptor.filePath, descriptor.size);
+  let firstMessage = null;
+  let model = null;
+  try {
+    const fd = fs.openSync(descriptor.filePath, 'r');
+    try {
+      const buffer = Buffer.alloc(64 * 1024);
+      const bytesRead = fs.readSync(fd, buffer, 0, buffer.length, 0);
+      const lines = buffer.subarray(0, bytesRead).toString('utf8')
+        .split(/\r?\n/).filter(line => line.trim());
+      const records = [];
+      for (const line of lines) {
+        try { records.push(JSON.parse(line)); } catch (_) {}
+      }
+      const state = records.length === 1 && records[0]?.messages
+        ? records[0]
+        : null;
+      const messages = state?.messages || records;
+      const firstUser = messages
+        .map(record => normalizeMessageRecord(record))
+        .find(message => message?.role === 'user' && message.content);
+      firstMessage = firstUser?.content || null;
+      model = messages.find(record => record?.model)?.model || null;
+    } finally {
+      fs.closeSync(fd);
+    }
+  } catch (_) {}
+  const projectPath = header.projectPath || descriptor.projectRoot || null;
+  const projectName = header.projectHash || descriptor.projectName
+    || (projectPath ? getFilePathHash(projectPath) : 'unknown');
+  return {
+    session: {
+      sessionId: header.sessionId || descriptor.sessionId,
+      projectName,
+      projectDisplayName: projectPath ? path.basename(projectPath) : `Project ${String(projectName).slice(0, 8)}`,
+      projectFullPath: projectPath,
+      firstMessage,
+      gitBranch: null,
+      provider: null,
+      model,
+      startedAt: null,
+      updatedAt: descriptor.mtimeMs,
+      extraJson: JSON.stringify({ projectPath, storageName: path.basename(path.dirname(path.dirname(descriptor.filePath))) })
+    }
+  };
+}
+
 /**
  * Parse a Gemini session file.
  */
@@ -341,4 +389,4 @@ async function parse(descriptor) {
   return { session, messages };
 }
 
-module.exports = { configure, inventory, parse, extractContentText, normalizeMessageRecord, parseSessionContent };
+module.exports = { configure, inventory, summarize, parse, extractContentText, normalizeMessageRecord, parseSessionContent };

package/src/platforms/drivers/gemini/sessions-implementation.js

@@ -649,7 +649,7 @@ function getProjectPath(projectHash, options = {}) {
  * @returns {Array} 项目对象数组
  */
 async function getProjects(options = {}) {
-  const projects = await getSessionHistoryIndex().listProjects('gemini', options);
+  const projects = await getSessionHistoryIndex().getAllProjects('gemini', options);
   const paths = buildPathMapping();
   return projects.map(project => {
     const fullPath = project.fullPath || paths.get(project.name) || null;
@@ -664,6 +664,25 @@ async function getProjects(options = {}) {
   });
 }
 
+async function getProjectsPage(options = {}) {
+  const payload = await getSessionHistoryIndex().listProjectsPage('gemini', options);
+  const paths = buildPathMapping();
+  return {
+    ...payload,
+    projects: payload.projects.map(project => {
+      const fullPath = project.fullPath || paths.get(project.name) || null;
+      return {
+        ...project,
+        displayName: fullPath ? path.basename(fullPath) : project.displayName,
+        path: fullPath,
+        fullPath,
+        storageName: fullPath ? path.basename(fullPath) : project.name,
+        lastUpdated: project.lastUsed ? new Date(project.lastUsed).toISOString() : null
+      };
+    })
+  };
+}
+
 /**
  * 获取指定项目的所有会话
  * @param {string} projectHash - 项目 hash
@@ -690,6 +709,30 @@ async function getProjectSessions(projectHash, options = {}) {
   }));
 }
 
+async function getProjectSessionsPage(projectHash, options = {}) {
+  const payload = await getSessionHistoryIndex().listSessionsPage('gemini', projectHash, options);
+  return {
+    ...payload,
+    sessions: payload.sessions.map(session => ({
+      sessionId: session.sessionId,
+      mtime: new Date(session.mtime).toISOString(),
+      size: session.size,
+      filePath: session.filePath,
+      gitBranch: null,
+      firstMessage: session.firstMessage,
+      forkedFrom: session.extra?.forkedFrom || null,
+      source: 'gemini',
+      tokens: session.tokens?.total ?? session.tokens ?? 0,
+      cost: session.extra?.cost || 0,
+      model: session.model || 'gemini-2.5-pro',
+      projectHash: session.projectName,
+      projectName: session.projectName,
+      storageName: session.extra?.storageName || session.projectName,
+      projectRoot: session.projectFullPath || null
+    }))
+  };
+}
+
 /**
  * 获取单个会话的完整内容
  * @param {string} sessionId - 会话 ID
@@ -936,7 +979,9 @@ module.exports = {
   configure,
   getAllSessions,
   getProjects,
+  getProjectsPage,
   getProjectSessions,
+  getProjectSessionsPage,
   getSession,
   getSessionById,
   deleteSession,

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

@@ -11,9 +11,10 @@ function createDriver(context = {}) {
     servicePath: './gemini/sessions-implementation',
     localServicePath: '../platforms/drivers/gemini/sessions-implementation',
     adapterLocalPath: '../platforms/drivers/gemini/session-history-adapter',
-    adapterMethods: { inventory: 'inventory', parse: 'parse' },
+    adapterMethods: { inventory: 'inventory', summarize: 'summarize', parse: 'parse' },
     methods: {
       listSessions: 'getProjectSessions',
+      listSessionsPage: 'getProjectSessionsPage',
       recent: 'getRecentSessions',
       getSessionById: 'getSessionById',
       getAllSessions: 'getAllSessions',

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

@@ -194,6 +194,47 @@ async function inventory({ projectsDir } = {}) {
   return descriptors;
 }
 
+async function summarize(descriptor) {
+  let entries = [];
+  let fd;
+  try {
+    fd = fs.openSync(descriptor.filePath, 'r');
+    const buffer = Buffer.alloc(64 * 1024);
+    const bytesRead = fs.readSync(fd, buffer, 0, buffer.length, 0);
+    entries = buffer.subarray(0, bytesRead).toString('utf8')
+      .split(/\r?\n/).filter(line => line.trim()).map(line => {
+        try { return JSON.parse(line); } catch (_) { return null; }
+      }).filter(Boolean);
+  } catch (_) {
+    entries = [];
+  } finally {
+    if (fd !== undefined) {
+      try { fs.closeSync(fd); } catch (_) {}
+    }
+  }
+  const header = entries.find(entry => entry?.type === 'session') || {};
+  const messages = entries.map(convertOmpEntry).filter(Boolean);
+  const firstUser = messages.find(message => message.type === 'user' && message.content);
+  const modelChange = [...entries].reverse().find(entry => entry?.type === 'model_change');
+  const cwd = header.cwd || header.project?.cwd || '';
+  const sessionId = header.id || descriptor.sessionId || parseOmpSessionId(descriptor.filePath);
+  return {
+    session: {
+      sessionId,
+      projectName: cwd ? encodeProjectName(cwd) : 'unknown',
+      projectDisplayName: getDisplayName(cwd),
+      projectFullPath: cwd || null,
+      firstMessage: firstUser?.content || null,
+      gitBranch: header.gitBranch || null,
+      provider: modelChange?.provider || messages.find(message => message.provider)?.provider || null,
+      model: modelChange?.modelId || modelChange?.model || messages.find(message => message.model)?.model || null,
+      startedAt: header.timestamp ? new Date(header.timestamp).getTime() : null,
+      updatedAt: descriptor.mtimeMs,
+      extraJson: JSON.stringify({ cwd: cwd || null })
+    }
+  };
+}
+
 /**
  * Parse an OMP session file.
  */
@@ -277,4 +318,4 @@ async function parse(descriptor) {
   return { session, messages };
 }
 
-module.exports = { configure, inventory, parse, convertOmpEntry, parseUsage, encodeProjectName: encodeProjectName, getDisplayName, readJsonLines, extractMessageText, normalizeTextContent };
+module.exports = { configure, inventory, summarize, parse, convertOmpEntry, parseUsage, encodeProjectName: encodeProjectName, getDisplayName, readJsonLines, extractMessageText, normalizeTextContent };

package/src/platforms/drivers/omp/sessions-implementation.js

@@ -331,7 +331,7 @@ function scanSessionFiles(rootDir = getOmpSessionPaths().sessions) {
 }
 
 async function getAllSessions(options = {}) {
-  const projects = await getSessionHistoryIndex().listProjects('omp', options);
+  const projects = await getSessionHistoryIndex().getAllProjects('omp', options);
   const groups = await Promise.all(projects.map(project => getSessionHistoryIndex().listSessions('omp', project.name, options)));
   return groups.flat().map(session => normalizeSession({
     ...session,
@@ -417,6 +417,24 @@ async function getProjects(options = {}) {
   return projects;
 }
 
+async function getProjectsPage(options = {}) {
+  const payload = await getSessionHistoryIndex().listProjectsPage('omp', options);
+  return {
+    ...payload,
+    projects: payload.projects.map(p => ({
+      name: p.name,
+      path: p.fullPath || p.path || '',
+      fullPath: p.fullPath || '',
+      displayName: p.displayName || p.name,
+      sessionCount: p.sessionCount || 0,
+      latestSession: p.latestSession || null,
+      mtime: p.lastUsed || null,
+      mtimeMs: p.lastUsed ? new Date(p.lastUsed).getTime() : 0,
+      source: 'omp'
+    }))
+  };
+}
+
 async function getSessionsByProject(projectName, options = {}) {
   const idxSessions = await getSessionHistoryIndex().listSessions('omp', projectName, options);
   const sessions = idxSessions.map(s => ({
@@ -450,6 +468,27 @@ async function getSessionsByProject(projectName, options = {}) {
   return sessions.map(normalizeSession);
 }
 
+async function getSessionsPage(projectName, options = {}) {
+  const payload = await getSessionHistoryIndex().listSessionsPage('omp', projectName, options);
+  return {
+    ...payload,
+    sessions: payload.sessions.map(s => normalizeSession({
+      sessionId: s.sessionId,
+      filePath: s.filePath,
+      firstMessage: s.firstMessage,
+      provider: s.provider,
+      model: s.model,
+      size: s.size,
+      mtime: new Date(s.mtime).toISOString(),
+      mtimeMs: s.mtime,
+      directory: s.projectFullPath,
+      cwd: s.projectFullPath,
+      messageCount: s.messageCount,
+      usage: s.tokens
+    }))
+  };
+}
+
 function normalizeSession(session) {
   if (!session) return null;
   return {
@@ -509,8 +548,15 @@ async function getRecentSessions(limit = 5) {
   }));
 }
 
-async function searchSessions(keyword, contextLength = 35, projectName = null) {
-  return getSessionHistoryIndex().searchSessions('omp', keyword, { contextLength, projectName });
+async function searchSessions(keyword, contextLength = 35, options = {}) {
+  const normalizedOptions = options && typeof options === 'object' && !Array.isArray(options)
+    ? options
+    : { projectName: typeof options === 'string' ? options : null };
+  return getSessionHistoryIndex().searchSessions('omp', keyword, {
+    ...normalizedOptions,
+    contextLength,
+    projectName: normalizedOptions.projectName || null
+  });
 }
 
 async function deleteSession(sessionId) {
@@ -611,10 +657,12 @@ module.exports = {
   getOmpSessionPaths,
   getProjectAndSessionCounts,
   getProjects,
+  getProjectsPage,
   getRecentSessions,
   getSessionById,
   getSessionMessages,
   getSessionsByProject,
+  getSessionsPage,
   isOmpInstalled: isOmpCliInstalled,
   normalizeSession,
   parseSessionFile,

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

@@ -11,12 +11,12 @@ function createDriver(context = {}) {
     servicePath: './omp/sessions-implementation',
     localServicePath: '../platforms/drivers/omp/sessions-implementation',
     adapterLocalPath: '../platforms/drivers/omp/session-history-adapter',
-    adapterMethods: { inventory: 'inventory', parse: 'parse' },
+    adapterMethods: { inventory: 'inventory', summarize: 'summarize', parse: 'parse' },
     methods: {
       getProjects: 'getProjects',
       listSessions: 'getSessionsByProject',
+      listSessionsPage: 'getSessionsPage',
       recent: 'getRecentSessions',
-      search: 'searchSessions',
       getSessionById: 'getSessionById',
       messages: 'getSessionMessages',
       delete: 'deleteSession',
@@ -25,6 +25,37 @@ function createDriver(context = {}) {
       buildLaunchCommand: 'buildLaunchCommand',
       status: 'getSessionStatus'
     },
+    customMethods: {
+      search: (service, requestOrProjectName, keyword, contextLength, options = {}) => {
+        if (requestOrProjectName && typeof requestOrProjectName === 'object' && !Array.isArray(requestOrProjectName)) {
+          const request = requestOrProjectName;
+          const query = request.query || {};
+          return service.searchSessions(query.keyword || query.q || '', Number(query.context) || 15, {
+            ...request,
+            ...options,
+            projectName: request.params?.projectName || null,
+            limit: Number.parseInt(query.limit, 10) || 100
+          });
+        }
+        return service.searchSessions(keyword, contextLength, {
+          ...options,
+          projectName: requestOrProjectName
+        });
+      },
+      searchAcrossProjects: (service, requestOrKeyword, limit, options = {}) => {
+        if (requestOrKeyword && typeof requestOrKeyword === 'object' && !Array.isArray(requestOrKeyword)) {
+          const request = requestOrKeyword;
+          const query = request.query || {};
+          return service.searchSessions(query.keyword || query.q || '', Number(query.context) || 35, {
+            ...request,
+            ...options,
+            projectName: query.projectName || query.project || null,
+            limit: Number.parseInt(query.limit, 10) || 35
+          });
+        }
+        return service.searchSessions(requestOrKeyword, Number(options.contextLength) || 35, { ...options, limit });
+      }
+    },
     onSuccess: operation => {
       if (['delete', 'fork', 'saveSessionOrder'].includes(operation)) {
         context.sessionHistoryIndex?.invalidateSource('omp');