coding-tool-x 3.8.4 → 3.8.6

package/src/{server/services → platforms}/commands-service.js

@@ -9,20 +9,73 @@ const fs = require('fs');
 const path = require('path');
 const toml = require('toml');
 const tomlStringify = require('@iarna/toml').stringify;
-const { RepoScannerBase } = require('./repo-scanner-base');
-const { NATIVE_PATHS } = require('../../config/paths');
+const { NATIVE_PATHS } = require('../config/paths');
+const { RepoScannerBase } = require('../server/services/repo-scanner-base');
+const { LocalResourceIndex } = require('../server/services/local-resource-index');
+const { createPlatformAccessError } = require('./access');
+const { getPlatformContext } = require('../server/platform-context');
 const {
   parseFrontmatter
-} = require('./format-converter');
+} = require('../server/services/format-converter');
 const {
   normalizeSafeFileStem,
   normalizeSafeRelativePath,
   resolveInsideRoot
-} = require('./config-artifact-paths');
+} = require('../shared/config-artifact-paths');
+
+function readMetadataPrefix(filePath, platform) {
+  const fd = fs.openSync(filePath, 'r');
+  const buffer = Buffer.alloc(8192);
+  const chunks = [];
+  let total = 0;
+  const isGemini = platform === 'gemini';
+  try {
+    while (total < (isGemini ? 64 * 1024 : 1024 * 1024)) {
+      const bytesRead = fs.readSync(fd, buffer, 0, buffer.length, null);
+      if (!bytesRead) break;
+      chunks.push(Buffer.from(buffer.subarray(0, bytesRead)));
+      total += bytesRead;
+      let text = Buffer.concat(chunks).toString('utf8');
+      if (text.charCodeAt(0) === 0xFEFF) text = text.slice(1);
+      if (!isGemini && total === bytesRead && !/^\s*---\s*(?:\n|$)/.test(text)) break;
+      if (isGemini && /^\s*description\s*=.*(?:\n|$)/m.test(text)) break;
+      if (!isGemini && /^\s*---\s*\n[\s\S]*?\n\s*---\s*(?:\n|$)/.test(text)) break;
+    }
+    let result = Buffer.concat(chunks).toString('utf8');
+    if (result.charCodeAt(0) === 0xFEFF) result = result.slice(1);
+    if (isGemini && !/^\s*description\s*=/m.test(result)) {
+      const stat = fs.fstatSync(fd);
+      if (stat.size > total) {
+        const remaining = stat.size - total;
+        const tailSize = Math.min(1024 * 1024, remaining);
+        const offset = remaining <= 1024 * 1024 ? total : stat.size - tailSize;
+        const tail = Buffer.alloc(tailSize);
+        const bytesRead = fs.readSync(fd, tail, 0, tailSize, offset);
+        result += `\n${tail.toString('utf8', 0, bytesRead)}`;
+      }
+    }
+    return result;
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+function parseCommandMetadata(filePath, platform) {
+  const content = readMetadataPrefix(filePath, platform);
+  if (platform === 'gemini') {
+    try {
+      const parsed = toml.parse(content);
+      return { frontmatter: {}, gemini: { description: parsed.description || '' } };
+    } catch (error) {
+      const match = content.match(/^\s*description\s*=\s*(.+)$/m);
+      return { frontmatter: {}, gemini: { description: match ? match[1].trim().replace(/^['"]|['"]$/g, '') : '', parseError: error.message } };
+    }
+  }
+  return { ...parseFrontmatter(content), gemini: null };
+}
 
 // 默认仓库源
 const DEFAULT_REPOS = [];
-const SUPPORTED_PLATFORMS = ['claude', 'codex', 'gemini', 'opencode', 'omp'];
 const OPENCODE_CONFIG_DIR = NATIVE_PATHS.opencode.config;
 const CLAUDE_COMMANDS_DIR = NATIVE_PATHS.claude.commands
   || path.join(NATIVE_PATHS.claude.dir || path.dirname(NATIVE_PATHS.claude.settings), 'commands');
@@ -67,7 +120,17 @@ const PLATFORM_CONFIG = {
 };
 
 function normalizePlatform(platform) {
-  return SUPPORTED_PLATFORMS.includes(platform) ? platform : 'claude';
+  const normalized = typeof platform === 'string' && platform.trim()
+    ? platform.trim().toLowerCase()
+    : 'claude';
+  if (!Object.prototype.hasOwnProperty.call(PLATFORM_CONFIG, normalized)) {
+    throw createPlatformAccessError('unsupported', {
+      platform: normalized,
+      capability: 'commands',
+      message: `Commands are not supported for ${normalized}`
+    });
+  }
+  return normalized;
 }
 
 /**
@@ -165,12 +228,9 @@ function parseGeminiCommandToml(content) {
 }
 
 function generateGeminiCommandToml({ description, body }) {
-  const data = {
-    prompt: body || ''
-  };
-  if (description) {
-    data.description = description;
-  }
+  const data = {};
+  if (description) data.description = description;
+  data.prompt = body || '';
   return tomlStringify(data);
 }
 
@@ -338,23 +398,114 @@ class CommandsRepoScanner extends RepoScannerBase {
  * Commands 服务类
  */
 class CommandsService {
-  constructor(platform = 'claude') {
+  constructor(platform = 'claude', { registry } = {}) {
     this.platform = normalizePlatform(platform);
     const config = PLATFORM_CONFIG[this.platform];
-
-    this.userCommandsDir = config.userCommandsDir;
+    this.registry = registry || (() => {
+      try {
+        return getPlatformContext().registry;
+      } catch {
+        return null;
+      }
+    })();
+    this.pathContext = null;
+    try {
+      if (typeof this.registry?.resolvePathContext === 'function') {
+        this.pathContext = this.registry.resolvePathContext(this.platform);
+      }
+    } catch {
+      this.pathContext = null;
+    }
+    const native = this.pathContext?.customized
+      ? (this.pathContext.native || {})
+      : (NATIVE_PATHS[this.platform] || {});
+    const configuredUserCommandsDir = this.pathContext?.customized
+      ? (native.commands
+        || (this.platform === 'opencode' ? path.join(native.config || OPENCODE_CONFIG_DIR, 'commands') : null)
+        || (native.dir ? path.join(native.dir, 'commands') : null))
+      : null;
+
+    this.userCommandsDir = configuredUserCommandsDir || config.userCommandsDir;
     if (this.platform === 'opencode') {
       const legacyUserDir = config.legacyUserCommandsDir;
-      if (legacyUserDir && fs.existsSync(legacyUserDir) && !fs.existsSync(this.userCommandsDir)) {
-        this.userCommandsDir = legacyUserDir;
+      const configuredLegacyUserDir = this.pathContext?.customized && native.config
+        ? path.join(native.config, 'command')
+        : legacyUserDir;
+      if (configuredLegacyUserDir && fs.existsSync(configuredLegacyUserDir) && !fs.existsSync(this.userCommandsDir)) {
+        this.userCommandsDir = configuredLegacyUserDir;
       }
     }
 
     this.projectCommandsDir = config.projectCommandsDir;
     this.repoScanner = new CommandsRepoScanner(this.platform, this.userCommandsDir);
     ensureDir(this.userCommandsDir);
+    this._localIndexes = new Map();
+    this._localIndexLimit = 32;
+  }
+
+  _getLocalIndex(scope, projectPath = null) {
+    const root = scope === 'user' ? this.userCommandsDir : this.getProjectCommandsDir(projectPath);
+    if (!root) return null;
+    const key = `${this.platform}:${scope}:${path.resolve(root)}`;
+    if (!this._localIndexes.has(key)) {
+      if (this._localIndexes.size >= this._localIndexLimit) {
+        const [oldKey, oldIndex] = this._localIndexes.entries().next().value;
+        oldIndex.dispose();
+        this._localIndexes.delete(oldKey);
+      }
+      const extension = getCommandFileExtension(this.platform);
+      this._localIndexes.set(key, new LocalResourceIndex({ key, roots: [root],
+        scanFile: (descriptor) => {
+          if (!descriptor.fullPath.endsWith(extension)) return null;
+          const parsed = parseCommandMetadata(descriptor.fullPath, this.platform);
+          const relativePath = descriptor.relativePath;
+          const commandName = path.basename(relativePath, extension);
+          const namespace = path.dirname(relativePath);
+          return {
+            name: commandName,
+            namespace: namespace === '.' ? null : namespace,
+            scope,
+            path: relativePath,
+            fullPath: descriptor.fullPath,
+            description: parsed.gemini?.description || parsed.frontmatter.description || '',
+            allowedTools: parsed.frontmatter['allowed-tools'] || '',
+            argumentHint: parsed.frontmatter['argument-hint'] || '',
+            agent: parsed.frontmatter.agent || '',
+            model: parsed.frontmatter.model || '',
+            subtask: parsed.frontmatter.subtask || '',
+            parseError: parsed.gemini?.parseError || '',
+            updatedAt: descriptor.stat.mtime.getTime()
+          };
+        },
+        detailFile: (summary) => {
+          const content = fs.readFileSync(summary.fullPath, 'utf-8');
+          const parsed = this.platform === 'gemini'
+            ? { frontmatter: {}, body: '', gemini: parseGeminiCommandToml(content) }
+            : { ...parseFrontmatter(content), gemini: null };
+          return {
+            body: parsed.gemini?.body ?? parsed.body,
+            fullContent: content,
+            parseError: parsed.gemini?.parseError || '',
+            updatedAt: fs.statSync(summary.fullPath).mtime.getTime()
+          };
+        }
+      }));
+    }
+    const index = this._localIndexes.get(key);
+    this._localIndexes.delete(key);
+    this._localIndexes.set(key, index);
+    return index;
+  }
+
+  _invalidateLocal(scope, projectPath = null) {
+    this._getLocalIndex(scope, projectPath)?.invalidate();
   }
 
+
+  dispose() {
+    for (const index of this._localIndexes.values()) index.dispose();
+    this._localIndexes.clear();
+  }
   getProjectCommandsDir(projectPath) {
     if (!projectPath) return null;
     return this.projectCommandsDir(projectPath);
@@ -406,133 +557,60 @@ class CommandsService {
    * @param {string} projectPath - 项目路径（可选，用于获取项目级命令）
    */
   listCommands(projectPath = null) {
-    const commands = [];
-
-    // 获取用户级命令
-    const userCommands = scanCommandsDir(this.userCommandsDir, this.userCommandsDir, 'user', this.platform);
-    commands.push(...userCommands);
-
-    // 获取项目级命令（如果提供了项目路径）
-    if (projectPath) {
-      const projectCommandsDir = this.getProjectCommandsDir(projectPath);
-      const projectCommands = scanCommandsDir(projectCommandsDir, projectCommandsDir, 'project', this.platform);
-      commands.push(...projectCommands);
-    }
-
-    // 按名称排序
+    const userCommands = this._getLocalIndex('user').listSync();
+    const projectCommands = projectPath ? this._getLocalIndex('project', projectPath).listSync() : [];
+    const commands = [...userCommands, ...projectCommands];
     commands.sort((a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase()));
-
     return {
       commands,
       total: commands.length,
       userCount: userCommands.length,
-      projectCount: commands.length - userCommands.length
+      projectCount: projectCommands.length
     };
   }
 
-  /**
-   * 获取所有命令（包括远程仓库）
-   * @param {boolean} forceRefresh - 强制刷新远程缓存
-   */
+  /** 获取所有命令（包括远程仓库） */
   async listAllCommands(projectPath = null, forceRefresh = false) {
-    // 获取本地命令
     const { commands: localCommands, userCount, projectCount } = this.listCommands(projectPath);
-
-    // 获取远程命令
     let remoteCommands = [];
     try {
       remoteCommands = await this.repoScanner.listRemoteItems(forceRefresh);
-
-      // 更新安装状态
-      for (const cmd of remoteCommands) {
-        cmd.installed = this.repoScanner.isInstalled(cmd.path);
-      }
+      for (const cmd of remoteCommands) cmd.installed = this.repoScanner.isInstalled(cmd.path);
     } catch (err) {
       console.warn('[CommandsService] Failed to fetch remote commands:', err.message);
     }
-
-    // 合并列表（本地优先）
     const allCommands = [...localCommands];
-    const localKeys = new Set(localCommands.map(c =>
-      c.namespace ? `${c.namespace}/${c.name}`.toLowerCase() : c.name.toLowerCase()
-    ));
-
+    const localKeys = new Set(localCommands.map(c => c.namespace ? `${c.namespace}/${c.name}`.toLowerCase() : c.name.toLowerCase()));
     for (const remote of remoteCommands) {
       const key = remote.namespace ? `${remote.namespace}/${remote.name}`.toLowerCase() : remote.name.toLowerCase();
-      if (!localKeys.has(key)) {
-        allCommands.push(remote);
-      }
+      if (!localKeys.has(key)) allCommands.push(remote);
     }
-
-    // 排序
     allCommands.sort((a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase()));
-
-    return {
-      commands: allCommands,
-      total: allCommands.length,
-      userCount,
-      projectCount,
-      remoteCount: remoteCommands.length
-    };
+    return { commands: allCommands, total: allCommands.length, userCount, projectCount, remoteCount: remoteCommands.length };
   }
 
-  /**
-   * 获取单个命令详情
-   */
+  /** 获取单个命令详情 */
   getCommand(name, scope, projectPath = null, namespace = null) {
     const safeName = normalizeCommandName(name);
     const safeNamespace = normalizeCommandNamespace(namespace);
     const baseDir = this._getBaseDir(scope, projectPath);
-    const { relativePath, fullPath } = this._resolveCommandPath(baseDir, safeName, safeNamespace);
-
-    if (!fs.existsSync(fullPath)) {
-      return null;
-    }
-
-    const content = fs.readFileSync(fullPath, 'utf-8');
-    const parsed = this.platform === 'gemini'
-      ? { frontmatter: {}, body: '', gemini: parseGeminiCommandToml(content) }
-      : { ...parseFrontmatter(content), gemini: null };
-
-    return {
-      name: safeName,
-      namespace: safeNamespace || null,
-      scope,
-      path: relativePath,
-      fullPath,
-      description: parsed.gemini?.description || parsed.frontmatter.description || '',
-      allowedTools: parsed.frontmatter['allowed-tools'] || '',
-      argumentHint: parsed.frontmatter['argument-hint'] || '',
-      agent: parsed.frontmatter.agent || '',
-      model: parsed.frontmatter.model || '',
-      subtask: parsed.frontmatter.subtask || '',
-      body: parsed.gemini?.body ?? parsed.body,
-      parseError: parsed.gemini?.parseError || '',
-      fullContent: content,
-      updatedAt: fs.statSync(fullPath).mtime.getTime()
-    };
+    const { relativePath } = this._resolveCommandPath(baseDir, safeName, safeNamespace);
+    const detail = this._getLocalIndex(scope, projectPath)?.getSync(relativePath);
+    if (!detail) return null;
+    return { ...detail, name: safeName, namespace: safeNamespace || null, scope, path: relativePath };
   }
 
-  /**
-   * 创建命令
-   */
+  /** 创建命令 */
   createCommand({ name, scope, projectPath, namespace, description, allowedTools, argumentHint, agent, model, subtask, body }) {
     const safeName = normalizeCommandName(name);
     const safeNamespace = normalizeCommandNamespace(namespace);
     const baseDir = this._getBaseDir(scope, projectPath);
     const { fullPath: filePath } = this._resolveCommandPath(baseDir, safeName, safeNamespace);
-    const targetDir = path.dirname(filePath);
-    ensureDir(targetDir);
-
-    // 检查是否已存在
-    if (fs.existsSync(filePath)) {
-      throw new Error(`命令 "${safeName}" 已存在`);
-    }
-
+    ensureDir(path.dirname(filePath));
+    if (fs.existsSync(filePath)) throw new Error(`命令 "${safeName}" 已存在`);
     const content = this._generateCommandContent({ description, allowedTools, argumentHint, agent, model, subtask, body });
-
     fs.writeFileSync(filePath, content, 'utf-8');
-
+    this._invalidateLocal(scope, projectPath);
     return this.getCommand(safeName, scope, projectPath, safeNamespace);
   }
 
@@ -550,9 +628,8 @@ class CommandsService {
     }
 
     const content = this._generateCommandContent({ description, allowedTools, argumentHint, agent, model, subtask, body });
-
     fs.writeFileSync(filePath, content, 'utf-8');
-
+    this._invalidateLocal(scope, projectPath);
     return this.getCommand(safeName, scope, projectPath, safeNamespace);
   }
 
@@ -584,6 +661,7 @@ class CommandsService {
       }
     }
 
+    this._invalidateLocal(scope, projectPath);
     return { success: true, message: '命令已删除' };
   }
 
@@ -645,14 +723,16 @@ class CommandsService {
    * 从远程仓库安装命令
    */
   async installFromRemote(command) {
-    return this.repoScanner.installCommand(command);
+    const result = await this.repoScanner.installCommand(command);
+    if (result && result.success !== false) this._invalidateLocal('user');
+    return result;
   }
 
-  /**
-   * 卸载命令
-   */
+  /** 卸载命令 */
   uninstallCommand(relativePath) {
-    return this.repoScanner.uninstall(relativePath);
+    const result = this.repoScanner.uninstall(relativePath);
+    if (result && result.success !== false) this._invalidateLocal('user');
+    return result;
   }
 
   // ==================== 格式转换 ====================

package/src/platforms/driver-registry.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const { createUnsupportedDriver } = require('./drivers/unsupported');
+const { createGenericJsonlDriver } = require('./drivers/generic-jsonl');
+const { createGenericFilesystemDriver } = require('./drivers/generic-filesystem');
+const { createGenericOpenAICompatibleDriver } = require('./drivers/generic-openai-compatible');
+const { createGenericMcpDriver } = require('./drivers/generic-mcp');
+const { createGenericPromptDriver } = require('./drivers/generic-prompt');
+const { registerLegacyDrivers } = require('./drivers/legacy');
+
+const DRIVER_ID_PATTERN = /^[a-z0-9:_-]+$/;
+
+function createDriverRegistry({ drivers = {} } = {}) {
+  const factories = new Map(Object.entries(drivers));
+
+  return {
+    register(id, factory) {
+      const driverId = String(id || '');
+      if (!DRIVER_ID_PATTERN.test(driverId) || typeof factory !== 'function') {
+        throw new Error(`Invalid capability driver: ${id}`);
+      }
+      factories.set(driverId, factory);
+    },
+    has(id) {
+      return factories.has(id);
+    },
+    create(id, context = {}) {
+      const factory = factories.get(id);
+      if (!factory) throw new Error(`Unknown capability driver: ${id}`);
+      return factory(context);
+    },
+    ids() {
+      return [...factories.keys()];
+    }
+  };
+}
+
+let defaultRegistry;
+
+function getDriverRegistry() {
+  if (!defaultRegistry) {
+    defaultRegistry = createDriverRegistry({
+      drivers: {
+        unsupported: createUnsupportedDriver,
+        'generic-jsonl': createGenericJsonlDriver,
+        'generic-filesystem': createGenericFilesystemDriver,
+        'generic-openai-compatible': createGenericOpenAICompatibleDriver,
+        'generic-mcp': createGenericMcpDriver,
+        'generic-prompt': createGenericPromptDriver,
+        'opencode-conversion': require('./drivers/opencode/conversion').createDriver,
+        'claude-health': require('./drivers/claude/health').createDriver
+      }
+    });
+    registerLegacyDrivers(defaultRegistry);
+  }
+  return defaultRegistry;
+}
+
+module.exports = { createDriverRegistry, getDriverRegistry };

package/src/platforms/drivers/claude/api-operations.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const os = require('os');
+const { createApiOperationsDriver } = require('../../../shared/driver-factories/api');
+
+function getHooksDriver(runtime) {
+  const driver = runtime?.getDriver?.('claude', 'hooks');
+  if (!driver || typeof driver.getHooks !== 'function') {
+    throw new Error('Claude hooks capability is unavailable');
+  }
+  return driver;
+}
+
+function toLegacyHooksResponse(status) {
+  return {
+    success: true,
+    stopHook: {
+      enabled: status?.enabled === true,
+      type: status?.type === 'dialog' || status?.type === 'browser' ? status.type : 'notification'
+    },
+    platform: os.platform()
+  };
+}
+
+function createDriver(context = {}) {
+  const { healthCheckAllProjects } = require('./health-check');
+  return createApiOperationsDriver({
+    ...context,
+    platform: 'claude',
+    operationHandlers: {
+      getHooks: (_requestContext, { runtime }) => {
+        const hooks = getHooksDriver(runtime || context.runtime);
+        return toLegacyHooksResponse(hooks.getHooks());
+      },
+      saveHooks: async (requestContext, { runtime }) => {
+        const hooks = getHooksDriver(runtime || context.runtime);
+        await hooks.saveHooks(requestContext.body?.stopHook || {});
+        return {
+          ...toLegacyHooksResponse(hooks.getHooks()),
+          message: '配置已保存'
+        };
+      },
+      testHooks: async (requestContext, { runtime }) => {
+        const hooks = getHooksDriver(runtime || context.runtime);
+        await hooks.testHooks(requestContext.body || {});
+        return { success: true, message: '系统测试通知已发送' };
+      },
+      healthCheck: async (_requestContext, { sessionHistoryIndex }) => {
+        const projects = sessionHistoryIndex
+          ? await sessionHistoryIndex.listProjects('claude', { consistency: 'stale-ok' })
+          : [];
+        return {
+          success: true,
+          timestamp: new Date().toISOString(),
+          ...healthCheckAllProjects(projects, { includeResults: true })
+        };
+      }
+    }
+  });
+}
+
+module.exports = { createDriver };