@kaitranntt/ccs 3.4.2 → 3.4.4

package/VERSION

@@ -1 +1 @@
-3.4.2
+3.4.4

package/bin/glmt/glmt-proxy.js

@@ -23,7 +23,7 @@ const DeltaAccumulator = require('./delta-accumulator');
  *
  * Debugging:
  * - Verbose: Pass --verbose to see request/response logs
- * - Debug: Set CCS_DEBUG_LOG=1 to write logs to ~/.ccs/logs/
+ * - Debug: Set CCS_DEBUG=1 to write logs to ~/.ccs/logs/
  *
  * Usage:
  *   const proxy = new GlmtProxy({ verbose: true });
@@ -33,7 +33,7 @@ class GlmtProxy {
   constructor(config = {}) {
     this.transformer = new GlmtTransformer({
       verbose: config.verbose,
-      debugLog: config.debugLog || process.env.CCS_DEBUG_LOG === '1'
+      debugLog: config.debugLog || process.env.CCS_DEBUG === '1' || process.env.CCS_DEBUG_LOG === '1'
     });
     // Use ANTHROPIC_BASE_URL from environment (set by settings.json) or fallback to Z.AI default
     this.upstreamUrl = process.env.ANTHROPIC_BASE_URL || 'https://api.z.ai/api/coding/paas/v4/chat/completions';
@@ -41,8 +41,6 @@ class GlmtProxy {
     this.port = null;
     this.verbose = config.verbose || false;
     this.timeout = config.timeout || 120000; // 120s default
-    this.streamingEnabled = process.env.CCS_GLMT_STREAMING !== 'disabled';
-    this.forceStreaming = process.env.CCS_GLMT_STREAMING === 'force';
   }
 
   /**
@@ -63,8 +61,7 @@ class GlmtProxy {
 
         // Info message (only show in verbose mode)
         if (this.verbose) {
-          const mode = this.streamingEnabled ? 'streaming mode' : 'buffered mode';
-          console.error(`[glmt] Proxy listening on port ${this.port} (${mode})`);
+          console.error(`[glmt] Proxy listening on port ${this.port} (streaming with auto-fallback)`);
         }
 
         // Debug mode notice
@@ -127,11 +124,21 @@ class GlmtProxy {
         this.log(`Request does NOT contain thinking parameter (will use message tags or default)`);
       }
 
-      // Branch: streaming or buffered
-      const useStreaming = (anthropicRequest.stream && this.streamingEnabled) || this.forceStreaming;
+      // Try streaming first (default), fallback to buffered on error
+      const useStreaming = anthropicRequest.stream !== false;
 
       if (useStreaming) {
-        await this._handleStreamingRequest(req, res, anthropicRequest, startTime);
+        try {
+          await this._handleStreamingRequest(req, res, anthropicRequest, startTime);
+        } catch (streamError) {
+          this.log(`Streaming failed: ${streamError.message}, retrying buffered mode`);
+          try {
+            await this._handleBufferedRequest(req, res, anthropicRequest, startTime);
+          } catch (bufferedError) {
+            // Both modes failed, propagate error
+            throw bufferedError;
+          }
+        }
       } else {
         await this._handleBufferedRequest(req, res, anthropicRequest, startTime);
       }

package/bin/glmt/glmt-transformer.js

@@ -8,8 +8,6 @@ const os = require('os');
 const SSEParser = require('./sse-parser');
 const DeltaAccumulator = require('./delta-accumulator');
 const LocaleEnforcer = require('./locale-enforcer');
-const BudgetCalculator = require('./budget-calculator');
-const TaskClassifier = require('./task-classifier');
 
 /**
  * GlmtTransformer - Convert between Anthropic and OpenAI formats with thinking and tool support
@@ -33,10 +31,23 @@ const TaskClassifier = require('./task-classifier');
  *   <Effort:Low|Medium|High> - Control reasoning depth
  */
 class GlmtTransformer {
+  static _warnedDeprecation = false;
+
   constructor(config = {}) {
     this.defaultThinking = config.defaultThinking ?? true;
     this.verbose = config.verbose || false;
-    this.debugLog = config.debugLog ?? process.env.CCS_DEBUG_LOG === '1';
+
+    // Support both CCS_DEBUG and CCS_DEBUG_LOG (with deprecation warning)
+    const oldVar = process.env.CCS_DEBUG_LOG === '1';
+    const newVar = process.env.CCS_DEBUG === '1';
+    this.debugLog = config.debugLog ?? (newVar || oldVar);
+
+    // Show deprecation warning once
+    if (oldVar && !newVar && !GlmtTransformer._warnedDeprecation) {
+      console.warn('[glmt] Warning: CCS_DEBUG_LOG is deprecated, use CCS_DEBUG instead');
+      GlmtTransformer._warnedDeprecation = true;
+    }
+
     this.debugLogDir = config.debugLogDir || path.join(os.homedir(), '.ccs', 'logs');
     this.modelMaxTokens = {
       'GLM-4.6': 128000,
@@ -47,14 +58,8 @@ class GlmtTransformer {
     this.EFFORT_LOW_THRESHOLD = 2048;
     this.EFFORT_HIGH_THRESHOLD = 8192;
 
-    // Initialize locale enforcer
-    this.localeEnforcer = new LocaleEnforcer({
-      forceEnglish: process.env.CCS_GLMT_FORCE_ENGLISH !== 'false'
-    });
-
-    // Initialize budget calculator and task classifier
-    this.budgetCalculator = new BudgetCalculator();
-    this.taskClassifier = new TaskClassifier();
+    // Initialize locale enforcer (always enforce English)
+    this.localeEnforcer = new LocaleEnforcer();
   }
 
   /**
@@ -73,25 +78,15 @@ class GlmtTransformer {
       );
       const hasControlTags = this._hasThinkingTags(anthropicRequest.messages || []);
 
-      // 2. Classify task type for intelligent thinking control
-      const taskType = this.taskClassifier.classify(anthropicRequest.messages || []);
-      this.log(`Task classified as: ${taskType}`);
-
-      // 3. Check budget and decide if thinking should be enabled
-      const envBudget = process.env.CCS_GLMT_THINKING_BUDGET;
-      const shouldThink = this.budgetCalculator.shouldEnableThinking(taskType, envBudget);
-      this.log(`Budget decision: thinking=${shouldThink} (budget: ${envBudget || 'default'}, type: ${taskType})`);
-
-      // Apply budget-based thinking control ONLY if:
-      // - No Claude CLI thinking parameter AND
-      // - No control tags in messages AND
-      // - Budget env var is explicitly set
-      if (!anthropicRequest.thinking && !hasControlTags && envBudget) {
-        thinkingConfig.thinking = shouldThink;
-        this.log('Applied budget-based thinking control');
+      // 2. Detect "think" keywords in user prompts (Anthropic-style)
+      const keywordConfig = this._detectThinkKeywords(anthropicRequest.messages || []);
+      if (keywordConfig && !anthropicRequest.thinking && !hasControlTags) {
+        thinkingConfig.thinking = keywordConfig.thinking;
+        thinkingConfig.effort = keywordConfig.effort;
+        this.log(`Detected think keyword: ${keywordConfig.keyword}, effort=${keywordConfig.effort}`);
       }
 
-      // 4. Check anthropicRequest.thinking parameter (takes precedence over budget)
+      // 3. Check anthropicRequest.thinking parameter (takes precedence)
       // Claude CLI sends this when alwaysThinkingEnabled is configured
       if (anthropicRequest.thinking) {
         if (anthropicRequest.thinking.type === 'enabled') {
@@ -440,6 +435,50 @@ class GlmtTransformer {
     };
   }
 
+  /**
+   * Detect Anthropic-style "think" keywords in user prompts
+   * Maps: "ultrathink" > "think harder" > "think hard" > "think"
+   * @param {Array} messages - Messages array
+   * @returns {Object|null} { thinking, effort, keyword } or null
+   * @private
+   */
+  _detectThinkKeywords(messages) {
+    if (!messages || messages.length === 0) return null;
+
+    // Extract text from user messages
+    const text = messages
+      .filter(m => m.role === 'user')
+      .map(m => {
+        if (typeof m.content === 'string') return m.content;
+        if (Array.isArray(m.content)) {
+          return m.content
+            .filter(block => block.type === 'text')
+            .map(block => block.text || '')
+            .join(' ');
+        }
+        return '';
+      })
+      .join(' ');
+
+    // Priority: ultrathink > think harder > think hard > think
+    // Effort levels: max > high > medium > low (matches Anthropic's 4-tier system)
+    // Use word boundaries to avoid matching "thinking", "rethink", etc.
+    if (/\bultrathink\b/i.test(text)) {
+      return { thinking: true, effort: 'max', keyword: 'ultrathink' };
+    }
+    if (/\bthink\s+harder\b/i.test(text)) {
+      return { thinking: true, effort: 'high', keyword: 'think harder' };
+    }
+    if (/\bthink\s+hard\b/i.test(text)) {
+      return { thinking: true, effort: 'medium', keyword: 'think hard' };
+    }
+    if (/\bthink\b/i.test(text)) {
+      return { thinking: true, effort: 'low', keyword: 'think' };
+    }
+
+    return null; // No keywords detected
+  }
+
   /**
    * Inject reasoning parameters into OpenAI request
    * @param {Object} openaiRequest - OpenAI request to modify

package/bin/glmt/locale-enforcer.js

@@ -5,15 +5,12 @@
  * LocaleEnforcer - Force English output from GLM models
  *
  * Purpose: GLM models default to Chinese when prompts are ambiguous or contain Chinese context.
- * This module injects "MUST respond in English" instruction into system prompt or first user message.
+ * This module always injects "MUST respond in English" instruction into system prompt or first user message.
  *
  * Usage:
- *   const enforcer = new LocaleEnforcer({ forceEnglish: true });
+ *   const enforcer = new LocaleEnforcer();
  *   const modifiedMessages = enforcer.injectInstruction(messages);
  *
- * Configuration:
- *   CCS_GLMT_FORCE_ENGLISH=false - Disable locale enforcement (allow multilingual)
- *
  * Strategy:
  *   1. If system prompt exists: Prepend instruction
  *   2. If no system prompt: Prepend to first user message
@@ -21,7 +18,6 @@
  */
 class LocaleEnforcer {
   constructor(options = {}) {
-    this.forceEnglish = options.forceEnglish ?? true;
     this.instruction = "CRITICAL: You MUST respond in English only, regardless of the input language or context. This is a strict requirement.";
   }
 
@@ -31,10 +27,6 @@ class LocaleEnforcer {
    * @returns {Array} Modified messages array
    */
   injectInstruction(messages) {
-    if (!this.forceEnglish) {
-      return messages;
-    }
-
     // Clone messages to avoid mutation
     const modifiedMessages = JSON.parse(JSON.stringify(messages));
 

package/lib/ccs

@@ -2,7 +2,7 @@
 set -euo pipefail
 
 # Version (updated by scripts/bump-version.sh)
-CCS_VERSION="3.4.1"
+CCS_VERSION="3.4.3"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 readonly CONFIG_FILE="${CCS_CONFIG:-$HOME/.ccs/config.json}"
 readonly PROFILES_JSON="$HOME/.ccs/profiles.json"

package/lib/ccs.ps1

@@ -12,7 +12,7 @@ param(
 $ErrorActionPreference = "Stop"
 
 # Version (updated by scripts/bump-version.sh)
-$CcsVersion = "3.4.1"
+$CcsVersion = "3.4.3"
 $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"

package/package.json

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

package/scripts/postinstall.js

@@ -93,7 +93,7 @@ function createConfigFiles() {
     // Migrate from v3.1.1 to v3.2.0 (symlink architecture)
     console.log('');
     try {
-      const SharedManager = require('../bin/shared-manager');
+      const SharedManager = require('../bin/management/shared-manager');
       const sharedManager = new SharedManager();
       sharedManager.migrateFromV311();
       sharedManager.ensureSharedDirectories();

package/bin/glmt/budget-calculator.js

@@ -1,114 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * BudgetCalculator - Control thinking enable/disable based on task complexity
- *
- * Purpose: Z.AI API only supports binary thinking (on/off), not reasoning_effort levels.
- * This module decides when to enable thinking based on task type and budget preferences.
- *
- * Usage:
- *   const calculator = new BudgetCalculator();
- *   const shouldThink = calculator.shouldEnableThinking(taskType, envBudget);
- *
- * Configuration:
- *   CCS_GLMT_THINKING_BUDGET:
- *     - 0 or "unlimited": Always enable thinking (power user mode)
- *     - 1-2048: Disable thinking (fast execution, low budget)
- *     - 2049-8192: Enable thinking for reasoning tasks only (default)
- *     - >8192: Always enable thinking (high budget)
- *
- * Task type mapping:
- *   - reasoning: Enable thinking (planning, design, analysis)
- *   - execution: Disable thinking (fix, implement, debug) unless high budget
- *   - mixed: Enable thinking if budget >= medium threshold
- */
-class BudgetCalculator {
-  constructor(options = {}) {
-    this.budgetThresholds = {
-      low: 2048,      // Disable thinking (fast execution)
-      medium: 8192    // Enable thinking for reasoning tasks
-    };
-    this.defaultBudget = options.defaultBudget || 8192; // Default: enable thinking for reasoning
-  }
-
-  /**
-   * Determine if thinking should be enabled based on task type and budget
-   * @param {string} taskType - 'reasoning', 'execution', or 'mixed'
-   * @param {string|number} envBudget - CCS_GLMT_THINKING_BUDGET value
-   * @returns {boolean} True if thinking should be enabled
-   */
-  shouldEnableThinking(taskType, envBudget) {
-    const budget = this._parseBudget(envBudget);
-
-    // Unlimited budget (0): Always enable thinking
-    if (budget === 0) {
-      return true;
-    }
-
-    // Low budget (<= 2048): Disable thinking (fast execution mode)
-    if (budget <= this.budgetThresholds.low) {
-      return false;
-    }
-
-    // High budget (> 8192): Always enable thinking
-    if (budget > this.budgetThresholds.medium) {
-      return true;
-    }
-
-    // Medium budget (2049-8192): Task-aware decision
-    if (taskType === 'reasoning') {
-      return true;  // Enable thinking for planning/design tasks
-    } else if (taskType === 'execution') {
-      return false; // Disable thinking for quick fixes
-    } else {
-      return true;  // Enable for mixed/ambiguous tasks (default safe)
-    }
-  }
-
-  /**
-   * Parse budget from environment variable or use default
-   * @param {string|number} envBudget - Budget value
-   * @returns {number} Parsed budget (0 = unlimited)
-   * @private
-   */
-  _parseBudget(envBudget) {
-    // CRITICAL: Check for undefined/null explicitly, not falsy (0 is valid!)
-    if (envBudget === undefined || envBudget === null || envBudget === '') {
-      return this.defaultBudget;
-    }
-
-    // Handle string values
-    if (typeof envBudget === 'string') {
-      if (envBudget.toLowerCase() === 'unlimited') {
-        return 0;
-      }
-      const parsed = parseInt(envBudget, 10);
-      if (isNaN(parsed)) {
-        return this.defaultBudget;
-      }
-      return parsed < 0 ? 0 : parsed;
-    }
-
-    // Handle number values
-    if (typeof envBudget === 'number') {
-      return envBudget < 0 ? 0 : envBudget;
-    }
-
-    return this.defaultBudget;
-  }
-
-  /**
-   * Get human-readable budget description
-   * @param {number} budget - Budget value
-   * @returns {string} Description
-   */
-  getBudgetDescription(budget) {
-    if (budget === 0) return 'unlimited (always think)';
-    if (budget <= this.budgetThresholds.low) return 'low (fast execution, no thinking)';
-    if (budget <= this.budgetThresholds.medium) return 'medium (task-aware thinking)';
-    return 'high (always think)';
-  }
-}
-
-module.exports = BudgetCalculator;

package/bin/glmt/task-classifier.js

@@ -1,162 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * TaskClassifier - Classify user prompts as reasoning, execution, or mixed tasks
- *
- * Purpose: Determine task type to inform thinking enable/disable decision.
- * Uses keyword-based matching for fast, deterministic classification.
- *
- * Usage:
- *   const classifier = new TaskClassifier();
- *   const taskType = classifier.classify(messages);
- *
- * Task types:
- *   - reasoning: Planning, design, analysis (enable thinking)
- *   - execution: Implementation, fixes, debugging (disable thinking for speed)
- *   - mixed: Ambiguous or both (default to safe thinking mode)
- *
- * Classification strategy:
- *   1. Extract text from all user messages
- *   2. Score against reasoning and execution keyword lists
- *   3. Return type with highest score (or 'mixed' if tied/no matches)
- */
-class TaskClassifier {
-  constructor(options = {}) {
-    this.keywords = {
-      reasoning: [
-        'plan', 'design', 'analyze', 'architecture', 'strategy',
-        'approach', 'consider', 'evaluate', 'research', 'explore',
-        'brainstorm', 'think about', 'pros and cons', 'alternatives',
-        'compare', 'recommend', 'assess', 'review', 'investigate'
-      ],
-      execution: [
-        'fix', 'implement', 'debug', 'refactor', 'optimize',
-        'add', 'remove', 'update', 'create', 'delete',
-        'change', 'modify', 'replace', 'move', 'rename',
-        'test', 'run', 'execute', 'deploy', 'build'
-      ]
-    };
-
-    // Allow custom keywords via options
-    if (options.customKeywords) {
-      this.keywords = { ...this.keywords, ...options.customKeywords };
-    }
-  }
-
-  /**
-   * Classify messages as reasoning, execution, or mixed
-   * @param {Array} messages - Messages array
-   * @returns {string} 'reasoning', 'execution', or 'mixed'
-   */
-  classify(messages) {
-    if (!messages || messages.length === 0) {
-      return 'mixed'; // Default to safe mode
-    }
-
-    // Extract text from all user messages
-    const text = messages
-      .filter(m => m.role === 'user')
-      .map(m => this._extractText(m.content))
-      .join(' ')
-      .toLowerCase();
-
-    if (!text.trim()) {
-      return 'mixed'; // No text found
-    }
-
-    // Score against keyword lists
-    const reasoningScore = this._matchScore(text, this.keywords.reasoning);
-    const executionScore = this._matchScore(text, this.keywords.execution);
-
-    // Classify based on scores
-    if (reasoningScore > executionScore) {
-      return 'reasoning';
-    } else if (executionScore > reasoningScore) {
-      return 'execution';
-    } else {
-      return 'mixed'; // Tied or no matches
-    }
-  }
-
-  /**
-   * Extract text from message content
-   * @param {string|Array} content - Message content
-   * @returns {string} Extracted text
-   * @private
-   */
-  _extractText(content) {
-    if (typeof content === 'string') {
-      return content;
-    }
-
-    if (Array.isArray(content)) {
-      return content
-        .filter(block => block.type === 'text')
-        .map(block => block.text || '')
-        .join(' ');
-    }
-
-    return '';
-  }
-
-  /**
-   * Calculate keyword match score
-   * @param {string} text - Text to search
-   * @param {Array} keywords - Keywords to match
-   * @returns {number} Number of matches
-   * @private
-   */
-  _matchScore(text, keywords) {
-    return keywords.reduce((score, keyword) => {
-      // Support both exact match and word boundary match
-      const regex = new RegExp(`\\b${this._escapeRegex(keyword)}\\b`, 'i');
-      return score + (regex.test(text) ? 1 : 0);
-    }, 0);
-  }
-
-  /**
-   * Escape special regex characters
-   * @param {string} str - String to escape
-   * @returns {string} Escaped string
-   * @private
-   */
-  _escapeRegex(str) {
-    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-  }
-
-  /**
-   * Get classification details (for debugging)
-   * @param {Array} messages - Messages array
-   * @returns {Object} { type, reasoningScore, executionScore, text }
-   */
-  classifyWithDetails(messages) {
-    const text = messages
-      .filter(m => m.role === 'user')
-      .map(m => this._extractText(m.content))
-      .join(' ')
-      .toLowerCase();
-
-    const reasoningScore = this._matchScore(text, this.keywords.reasoning);
-    const executionScore = this._matchScore(text, this.keywords.execution);
-
-    let type;
-    if (reasoningScore > executionScore) {
-      type = 'reasoning';
-    } else if (executionScore > reasoningScore) {
-      type = 'execution';
-    } else {
-      type = 'mixed';
-    }
-
-    return {
-      type,
-      reasoningScore,
-      executionScore,
-      textLength: text.length,
-      textPreview: text.substring(0, 100) + (text.length > 100 ? '...' : '')
-    };
-  }
-}
-
-module.exports = TaskClassifier;