@kaitranntt/ccs 3.2.0 → 3.3.0

package/bin/glmt-transformer.js

@@ -0,0 +1,437 @@
+#!/usr/bin/env node
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * GlmtTransformer - Convert between Anthropic and OpenAI formats with thinking support
+ *
+ * Features:
+ * - Request: Anthropic → OpenAI (inject reasoning params)
+ * - Response: OpenAI reasoning_content → Anthropic thinking blocks
+ * - Debug mode: Log raw data to ~/.ccs/logs/ (CCS_DEBUG_LOG=1)
+ * - Verbose mode: Console logging with timestamps
+ * - Validation: Self-test transformation results
+ *
+ * Usage:
+ *   const transformer = new GlmtTransformer({ verbose: true, debugLog: true });
+ *   const { openaiRequest, thinkingConfig } = transformer.transformRequest(req);
+ *   const anthropicResponse = transformer.transformResponse(resp, thinkingConfig);
+ *
+ * Control Tags (in user prompt):
+ *   <Thinking:On|Off>        - Enable/disable reasoning
+ *   <Effort:Low|Medium|High> - Control reasoning depth
+ */
+class GlmtTransformer {
+  constructor(config = {}) {
+    this.defaultThinking = config.defaultThinking ?? true;
+    this.verbose = config.verbose || false;
+    this.debugLog = config.debugLog ?? process.env.CCS_DEBUG_LOG === '1';
+    this.debugLogDir = config.debugLogDir || path.join(os.homedir(), '.ccs', 'logs');
+    this.modelMaxTokens = {
+      'GLM-4.6': 128000,
+      'GLM-4.5': 96000,
+      'GLM-4.5-air': 16000
+    };
+  }
+
+  /**
+   * Transform Anthropic request to OpenAI format
+   * @param {Object} anthropicRequest - Anthropic Messages API request
+   * @returns {Object} { openaiRequest, thinkingConfig }
+   */
+  transformRequest(anthropicRequest) {
+    // Log original request
+    this._writeDebugLog('request-anthropic', anthropicRequest);
+
+    try {
+      // 1. Extract thinking control from messages
+      const thinkingConfig = this._extractThinkingControl(
+        anthropicRequest.messages || []
+      );
+      this.log(`Extracted thinking control: ${JSON.stringify(thinkingConfig)}`);
+
+      // 2. Map model
+      const glmModel = this._mapModel(anthropicRequest.model);
+
+      // 3. Convert to OpenAI format
+      const openaiRequest = {
+        model: glmModel,
+        messages: this._sanitizeMessages(anthropicRequest.messages || []),
+        max_tokens: this._getMaxTokens(glmModel),
+        stream: anthropicRequest.stream ?? false
+      };
+
+      // 4. Preserve optional parameters
+      if (anthropicRequest.temperature !== undefined) {
+        openaiRequest.temperature = anthropicRequest.temperature;
+      }
+      if (anthropicRequest.top_p !== undefined) {
+        openaiRequest.top_p = anthropicRequest.top_p;
+      }
+
+      // 5. Handle streaming (not yet supported)
+      // Silently override to buffered mode
+      if (anthropicRequest.stream) {
+        openaiRequest.stream = false;
+      }
+
+      // 6. Inject reasoning parameters
+      this._injectReasoningParams(openaiRequest, thinkingConfig);
+
+      // Log transformed request
+      this._writeDebugLog('request-openai', openaiRequest);
+
+      return { openaiRequest, thinkingConfig };
+    } catch (error) {
+      console.error('[glmt-transformer] Request transformation error:', error);
+      // Return original request with warning
+      return {
+        openaiRequest: anthropicRequest,
+        thinkingConfig: { thinking: false },
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Transform OpenAI response to Anthropic format
+   * @param {Object} openaiResponse - OpenAI Chat Completions response
+   * @param {Object} thinkingConfig - Config from request transformation
+   * @returns {Object} Anthropic Messages API response
+   */
+  transformResponse(openaiResponse, thinkingConfig = {}) {
+    // Log original response
+    this._writeDebugLog('response-openai', openaiResponse);
+
+    try {
+      const choice = openaiResponse.choices?.[0];
+      if (!choice) {
+        throw new Error('No choices in OpenAI response');
+      }
+
+      const message = choice.message;
+      const content = [];
+
+      // Add thinking block if reasoning_content exists
+      if (message.reasoning_content) {
+        const length = message.reasoning_content.length;
+        const lineCount = message.reasoning_content.split('\n').length;
+        const preview = message.reasoning_content
+          .substring(0, 100)
+          .replace(/\n/g, ' ')
+          .trim();
+
+        this.log(`Detected reasoning_content:`);
+        this.log(`  Length: ${length} characters`);
+        this.log(`  Lines: ${lineCount}`);
+        this.log(`  Preview: ${preview}...`);
+
+        content.push({
+          type: 'thinking',
+          thinking: message.reasoning_content,
+          signature: this._generateThinkingSignature(message.reasoning_content)
+        });
+      } else {
+        this.log('No reasoning_content in OpenAI response');
+        this.log('Note: This is expected if thinking not requested or model cannot reason');
+      }
+
+      // Add text content
+      if (message.content) {
+        content.push({
+          type: 'text',
+          text: message.content
+        });
+      }
+
+      // Handle tool_calls if present
+      if (message.tool_calls && message.tool_calls.length > 0) {
+        message.tool_calls.forEach(toolCall => {
+          content.push({
+            type: 'tool_use',
+            id: toolCall.id,
+            name: toolCall.function.name,
+            input: JSON.parse(toolCall.function.arguments || '{}')
+          });
+        });
+      }
+
+      const anthropicResponse = {
+        id: openaiResponse.id || 'msg_' + Date.now(),
+        type: 'message',
+        role: 'assistant',
+        content: content,
+        model: openaiResponse.model || 'glm-4.6',
+        stop_reason: this._mapStopReason(choice.finish_reason),
+        usage: openaiResponse.usage || {
+          input_tokens: 0,
+          output_tokens: 0
+        }
+      };
+
+      // Validate transformation in verbose mode
+      if (this.verbose) {
+        const validation = this._validateTransformation(anthropicResponse);
+        this.log(`Transformation validation: ${validation.passed}/${validation.total} checks passed`);
+        if (!validation.valid) {
+          this.log(`Failed checks: ${JSON.stringify(validation.checks, null, 2)}`);
+        }
+      }
+
+      // Log transformed response
+      this._writeDebugLog('response-anthropic', anthropicResponse);
+
+      return anthropicResponse;
+    } catch (error) {
+      console.error('[glmt-transformer] Response transformation error:', error);
+      // Return minimal valid response
+      return {
+        id: 'msg_error_' + Date.now(),
+        type: 'message',
+        role: 'assistant',
+        content: [{
+          type: 'text',
+          text: '[Transformation Error] ' + error.message
+        }],
+        stop_reason: 'end_turn',
+        usage: { input_tokens: 0, output_tokens: 0 }
+      };
+    }
+  }
+
+  /**
+   * Sanitize messages for OpenAI API compatibility
+   * Remove thinking blocks and unsupported content types
+   * @param {Array} messages - Messages array
+   * @returns {Array} Sanitized messages
+   * @private
+   */
+  _sanitizeMessages(messages) {
+    return messages.map(msg => {
+      // If content is a string, return as-is
+      if (typeof msg.content === 'string') {
+        return msg;
+      }
+
+      // If content is an array, filter out unsupported types
+      if (Array.isArray(msg.content)) {
+        const sanitizedContent = msg.content
+          .filter(block => {
+            // Keep only text content for OpenAI
+            // Filter out: thinking, tool_use, tool_result, etc.
+            return block.type === 'text';
+          })
+          .map(block => {
+            // Return just the text content
+            return block;
+          });
+
+        // If we filtered everything out, return empty string
+        if (sanitizedContent.length === 0) {
+          return {
+            role: msg.role,
+            content: ''
+          };
+        }
+
+        // If only one text block, convert to string
+        if (sanitizedContent.length === 1 && sanitizedContent[0].type === 'text') {
+          return {
+            role: msg.role,
+            content: sanitizedContent[0].text
+          };
+        }
+
+        // Return array of text blocks
+        return {
+          role: msg.role,
+          content: sanitizedContent
+        };
+      }
+
+      // Fallback: return message as-is
+      return msg;
+    });
+  }
+
+  /**
+   * Extract thinking control tags from user messages
+   * @param {Array} messages - Messages array
+   * @returns {Object} { thinking: boolean, effort: string }
+   * @private
+   */
+  _extractThinkingControl(messages) {
+    const config = {
+      thinking: this.defaultThinking,
+      effort: 'medium'
+    };
+
+    // Scan user messages for control tags
+    for (const msg of messages) {
+      if (msg.role !== 'user') continue;
+
+      const content = msg.content;
+      if (typeof content !== 'string') continue;
+
+      // Check for <Thinking:On|Off>
+      const thinkingMatch = content.match(/<Thinking:(On|Off)>/i);
+      if (thinkingMatch) {
+        config.thinking = thinkingMatch[1].toLowerCase() === 'on';
+      }
+
+      // Check for <Effort:Low|Medium|High>
+      const effortMatch = content.match(/<Effort:(Low|Medium|High)>/i);
+      if (effortMatch) {
+        config.effort = effortMatch[1].toLowerCase();
+      }
+    }
+
+    return config;
+  }
+
+  /**
+   * Generate thinking signature for Claude Code UI
+   * @param {string} thinking - Thinking content
+   * @returns {Object} Signature object
+   * @private
+   */
+  _generateThinkingSignature(thinking) {
+    // Generate signature hash
+    const hash = crypto.createHash('sha256')
+      .update(thinking)
+      .digest('hex')
+      .substring(0, 16);
+
+    return {
+      type: 'thinking_signature',
+      hash: hash,
+      length: thinking.length,
+      timestamp: Date.now()
+    };
+  }
+
+  /**
+   * Inject reasoning parameters into OpenAI request
+   * @param {Object} openaiRequest - OpenAI request to modify
+   * @param {Object} thinkingConfig - Thinking configuration
+   * @returns {Object} Modified request
+   * @private
+   */
+  _injectReasoningParams(openaiRequest, thinkingConfig) {
+    // Always enable sampling for temperature/top_p to work
+    openaiRequest.do_sample = true;
+
+    // Add thinking-specific parameters if enabled
+    if (thinkingConfig.thinking) {
+      // Z.AI may support these parameters (based on research)
+      openaiRequest.reasoning = true;
+      openaiRequest.reasoning_effort = thinkingConfig.effort;
+    }
+
+    return openaiRequest;
+  }
+
+  /**
+   * Map Anthropic model to GLM model
+   * @param {string} anthropicModel - Anthropic model name
+   * @returns {string} GLM model name
+   * @private
+   */
+  _mapModel(anthropicModel) {
+    // Default to GLM-4.6 (latest and most capable)
+    return 'GLM-4.6';
+  }
+
+  /**
+   * Get max tokens for model
+   * @param {string} model - Model name
+   * @returns {number} Max tokens
+   * @private
+   */
+  _getMaxTokens(model) {
+    return this.modelMaxTokens[model] || 128000;
+  }
+
+  /**
+   * Map OpenAI stop reason to Anthropic stop reason
+   * @param {string} openaiReason - OpenAI finish_reason
+   * @returns {string} Anthropic stop_reason
+   * @private
+   */
+  _mapStopReason(openaiReason) {
+    const mapping = {
+      'stop': 'end_turn',
+      'length': 'max_tokens',
+      'tool_calls': 'tool_use',
+      'content_filter': 'stop_sequence'
+    };
+    return mapping[openaiReason] || 'end_turn';
+  }
+
+  /**
+   * Write debug log to file
+   * @param {string} type - 'request-anthropic', 'request-openai', 'response-openai', 'response-anthropic'
+   * @param {object} data - Data to log
+   * @private
+   */
+  _writeDebugLog(type, data) {
+    if (!this.debugLog) return;
+
+    try {
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-').split('.')[0];
+      const filename = `${timestamp}-${type}.json`;
+      const filepath = path.join(this.debugLogDir, filename);
+
+      // Ensure directory exists
+      fs.mkdirSync(this.debugLogDir, { recursive: true });
+
+      // Write file (pretty-printed)
+      fs.writeFileSync(filepath, JSON.stringify(data, null, 2) + '\n', 'utf8');
+
+      if (this.verbose) {
+        this.log(`Debug log written: ${filepath}`);
+      }
+    } catch (error) {
+      console.error(`[glmt-transformer] Failed to write debug log: ${error.message}`);
+    }
+  }
+
+  /**
+   * Validate transformed Anthropic response
+   * @param {object} anthropicResponse - Response to validate
+   * @returns {object} Validation results
+   * @private
+   */
+  _validateTransformation(anthropicResponse) {
+    const checks = {
+      hasContent: Boolean(anthropicResponse.content && anthropicResponse.content.length > 0),
+      hasThinking: anthropicResponse.content?.some(block => block.type === 'thinking') || false,
+      hasText: anthropicResponse.content?.some(block => block.type === 'text') || false,
+      validStructure: anthropicResponse.type === 'message' && anthropicResponse.role === 'assistant',
+      hasUsage: Boolean(anthropicResponse.usage)
+    };
+
+    const passed = Object.values(checks).filter(Boolean).length;
+    const total = Object.keys(checks).length;
+
+    return { checks, passed, total, valid: passed === total };
+  }
+
+  /**
+   * Log message if verbose
+   * @param {string} message - Message to log
+   * @private
+   */
+  log(message) {
+    if (this.verbose) {
+      const timestamp = new Date().toTimeString().split(' ')[0]; // HH:MM:SS
+      console.error(`[glmt-transformer] [${timestamp}] ${message}`);
+    }
+  }
+}
+
+module.exports = GlmtTransformer;

package/config/base-glmt.settings.json

@@ -0,0 +1,17 @@
+{
+  "env": {
+    "ANTHROPIC_BASE_URL": "https://api.z.ai/api/coding/paas/v4/chat/completions",
+    "ANTHROPIC_AUTH_TOKEN": "YOUR_GLM_API_KEY_HERE",
+    "ANTHROPIC_MODEL": "glm-4.6",
+    "ANTHROPIC_DEFAULT_OPUS_MODEL": "glm-4.6",
+    "ANTHROPIC_DEFAULT_SONNET_MODEL": "glm-4.6",
+    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "glm-4.6",
+    "ANTHROPIC_TEMPERATURE": "0.2",
+    "ANTHROPIC_MAX_TOKENS": "65536",
+    "MAX_THINKING_TOKENS": "32768",
+    "ENABLE_STREAMING": "true",
+    "ANTHROPIC_SAFE_MODE": "false",
+    "API_TIMEOUT_MS": "3000000"
+  },
+  "alwaysThinkingEnabled": true
+}

package/lib/ccs

@@ -2,7 +2,7 @@
 set -euo pipefail
 
 # Version (updated by scripts/bump-version.sh)
-CCS_VERSION="3.2.0"
+CCS_VERSION="3.3.0"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 readonly CONFIG_FILE="${CCS_CONFIG:-$HOME/.ccs/config.json}"
 readonly PROFILES_JSON="$HOME/.ccs/profiles.json"
@@ -51,6 +51,7 @@ show_help() {
   echo -e "${CYAN}Model Switching:${RESET}"
   echo -e "  ${YELLOW}ccs${RESET}                         Use default Claude account"
   echo -e "  ${YELLOW}ccs glm${RESET}                     Switch to GLM 4.6 model"
+  echo -e "  ${YELLOW}ccs glmt${RESET}                    Switch to GLM with thinking mode"
   echo -e "  ${YELLOW}ccs kimi${RESET}                    Switch to Kimi for Coding"
   echo -e "  ${YELLOW}ccs glm${RESET} \"debug this code\"   Use GLM and run command"
   echo ""

package/lib/ccs.ps1

@@ -12,7 +12,7 @@ param(
 $ErrorActionPreference = "Stop"
 
 # Version (updated by scripts/bump-version.sh)
-$CcsVersion = "3.2.0"
+$CcsVersion = "3.3.0"
 $ScriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
 $ConfigFile = if ($env:CCS_CONFIG) { $env:CCS_CONFIG } else { "$env:USERPROFILE\.ccs\config.json" }
 $ProfilesJson = "$env:USERPROFILE\.ccs\profiles.json"
@@ -107,6 +107,7 @@ function Show-Help {
     Write-ColorLine "Model Switching:" "Cyan"
     Write-ColorLine "  ccs                         Use default Claude account" "Yellow"
     Write-ColorLine "  ccs glm                     Switch to GLM 4.6 model" "Yellow"
+    Write-ColorLine "  ccs glmt                    Switch to GLM with thinking mode" "Yellow"
     Write-ColorLine "  ccs kimi                    Switch to Kimi for Coding" "Yellow"
     Write-ColorLine "  ccs glm 'debug this code'   Use GLM and run command" "Yellow"
     Write-Host ""

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaitranntt/ccs",
-  "version": "3.2.0",
+  "version": "3.3.0",
   "description": "Claude Code Switch - Instant profile switching between Claude Sonnet 4.5 and GLM 4.6",
   "keywords": [
     "cli",

package/scripts/postinstall.js

@@ -33,6 +33,7 @@ function validateConfiguration() {
   const requiredFiles = [
     { path: path.join(ccsDir, 'config.json'), name: 'config.json' },
     { path: path.join(ccsDir, 'glm.settings.json'), name: 'glm.settings.json' },
+    { path: path.join(ccsDir, 'glmt.settings.json'), name: 'glmt.settings.json' },
     { path: path.join(ccsDir, 'kimi.settings.json'), name: 'kimi.settings.json' }
   ];
 
@@ -108,6 +109,7 @@ function createConfigFiles() {
       const config = {
         profiles: {
           glm: '~/.ccs/glm.settings.json',
+          glmt: '~/.ccs/glmt.settings.json',
           kimi: '~/.ccs/kimi.settings.json',
           default: '~/.claude/settings.json'
         }
@@ -120,7 +122,21 @@ function createConfigFiles() {
 
       console.log('[OK] Created config: ~/.ccs/config.json');
     } else {
-      console.log('[OK] Config exists: ~/.ccs/config.json (preserved)');
+      // Update existing config with glmt if missing (migration for v3.x users)
+      const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      // Ensure profiles object exists
+      if (!config.profiles) {
+        config.profiles = {};
+      }
+      if (!config.profiles.glmt) {
+        config.profiles.glmt = '~/.ccs/glmt.settings.json';
+        const tmpPath = `${configPath}.tmp`;
+        fs.writeFileSync(tmpPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
+        fs.renameSync(tmpPath, configPath);
+        console.log('[OK] Updated config with GLMT profile');
+      } else {
+        console.log('[OK] Config exists: ~/.ccs/config.json (preserved)');
+      }
     }
 
     // Create glm.settings.json if missing
@@ -152,6 +168,94 @@ function createConfigFiles() {
       console.log('[OK] GLM profile exists: ~/.ccs/glm.settings.json (preserved)');
     }
 
+    // Create glmt.settings.json if missing
+    const glmtSettingsPath = path.join(ccsDir, 'glmt.settings.json');
+    if (!fs.existsSync(glmtSettingsPath)) {
+      const glmtSettings = {
+        env: {
+          ANTHROPIC_BASE_URL: 'https://api.z.ai/api/coding/paas/v4/chat/completions',
+          ANTHROPIC_AUTH_TOKEN: 'YOUR_GLM_API_KEY_HERE',
+          ANTHROPIC_MODEL: 'glm-4.6',
+          ANTHROPIC_DEFAULT_OPUS_MODEL: 'glm-4.6',
+          ANTHROPIC_DEFAULT_SONNET_MODEL: 'glm-4.6',
+          ANTHROPIC_DEFAULT_HAIKU_MODEL: 'glm-4.6',
+          ANTHROPIC_TEMPERATURE: '0.2',
+          ANTHROPIC_MAX_TOKENS: '65536',
+          MAX_THINKING_TOKENS: '32768',
+          ENABLE_STREAMING: 'true',
+          ANTHROPIC_SAFE_MODE: 'false',
+          API_TIMEOUT_MS: '3000000'
+        },
+        alwaysThinkingEnabled: true
+      };
+
+      // Atomic write
+      const tmpPath = `${glmtSettingsPath}.tmp`;
+      fs.writeFileSync(tmpPath, JSON.stringify(glmtSettings, null, 2) + '\n', 'utf8');
+      fs.renameSync(tmpPath, glmtSettingsPath);
+
+      console.log('[OK] Created GLMT profile: ~/.ccs/glmt.settings.json');
+      console.log('');
+      console.log('  [!] Configure GLMT API key:');
+      console.log('      1. Get key from: https://api.z.ai');
+      console.log('      2. Edit: ~/.ccs/glmt.settings.json');
+      console.log('      3. Replace: YOUR_GLM_API_KEY_HERE');
+      console.log('      Note: GLMT enables GLM thinking mode (reasoning)');
+      console.log('      Defaults: Temperature 0.2, thinking enabled, 50min timeout');
+    } else {
+      console.log('[OK] GLMT profile exists: ~/.ccs/glmt.settings.json (preserved)');
+    }
+
+    // Migrate existing GLMT configs to include new defaults (v3.3.0)
+    if (fs.existsSync(glmtSettingsPath)) {
+      try {
+        const existing = JSON.parse(fs.readFileSync(glmtSettingsPath, 'utf8'));
+        let updated = false;
+
+        // Ensure env object exists
+        if (!existing.env) {
+          existing.env = {};
+          updated = true;
+        }
+
+        // Add missing env vars (preserve existing values)
+        const envDefaults = {
+          ANTHROPIC_TEMPERATURE: '0.2',
+          ANTHROPIC_MAX_TOKENS: '65536',
+          MAX_THINKING_TOKENS: '32768',
+          ENABLE_STREAMING: 'true',
+          ANTHROPIC_SAFE_MODE: 'false',
+          API_TIMEOUT_MS: '3000000'
+        };
+
+        for (const [key, value] of Object.entries(envDefaults)) {
+          if (existing.env[key] === undefined) {
+            existing.env[key] = value;
+            updated = true;
+          }
+        }
+
+        // Add alwaysThinkingEnabled if missing
+        if (existing.alwaysThinkingEnabled === undefined) {
+          existing.alwaysThinkingEnabled = true;
+          updated = true;
+        }
+
+        // Write back if updated
+        if (updated) {
+          const tmpPath = `${glmtSettingsPath}.tmp`;
+          fs.writeFileSync(tmpPath, JSON.stringify(existing, null, 2) + '\n', 'utf8');
+          fs.renameSync(tmpPath, glmtSettingsPath);
+          console.log('[OK] Migrated GLMT config with new defaults (v3.3.0)');
+          console.log('     Added: temperature, max_tokens, thinking settings, alwaysThinkingEnabled');
+        }
+      } catch (err) {
+        console.warn('[!] GLMT config migration failed:', err.message);
+        console.warn('    Existing config preserved, may be missing new defaults');
+        console.warn('    You can manually add fields or delete file to regenerate');
+      }
+    }
+
     // Create kimi.settings.json if missing
     const kimiSettingsPath = path.join(ccsDir, 'kimi.settings.json');
     if (!fs.existsSync(kimiSettingsPath)) {