@kaitranntt/ccs 3.3.0 → 3.4.1

package/bin/glmt/locale-enforcer.js

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * 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.
+ *
+ * Usage:
+ *   const enforcer = new LocaleEnforcer({ forceEnglish: true });
+ *   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
+ *   3. Preserve message structure (string vs array content)
+ */
+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.";
+  }
+
+  /**
+   * Inject English instruction into messages
+   * @param {Array} messages - Messages array to modify
+   * @returns {Array} Modified messages array
+   */
+  injectInstruction(messages) {
+    if (!this.forceEnglish) {
+      return messages;
+    }
+
+    // Clone messages to avoid mutation
+    const modifiedMessages = JSON.parse(JSON.stringify(messages));
+
+    // Strategy 1: Inject into system prompt (preferred)
+    const systemIndex = modifiedMessages.findIndex(m => m.role === 'system');
+    if (systemIndex >= 0) {
+      const systemMsg = modifiedMessages[systemIndex];
+
+      if (typeof systemMsg.content === 'string') {
+        systemMsg.content = `${this.instruction}\n\n${systemMsg.content}`;
+      } else if (Array.isArray(systemMsg.content)) {
+        systemMsg.content.unshift({
+          type: 'text',
+          text: this.instruction
+        });
+      }
+
+      return modifiedMessages;
+    }
+
+    // Strategy 2: Prepend to first user message
+    const userIndex = modifiedMessages.findIndex(m => m.role === 'user');
+    if (userIndex >= 0) {
+      const userMsg = modifiedMessages[userIndex];
+
+      if (typeof userMsg.content === 'string') {
+        userMsg.content = `${this.instruction}\n\n${userMsg.content}`;
+      } else if (Array.isArray(userMsg.content)) {
+        userMsg.content.unshift({
+          type: 'text',
+          text: this.instruction
+        });
+      }
+
+      return modifiedMessages;
+    }
+
+    // No system or user messages found (edge case)
+    return modifiedMessages;
+  }
+}
+
+module.exports = LocaleEnforcer;

package/bin/glmt/sse-parser.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * SSEParser - Parse Server-Sent Events (SSE) stream
+ *
+ * Handles:
+ * - Incomplete events across chunks
+ * - Multiple events in single chunk
+ * - Malformed data (skip gracefully)
+ * - [DONE] marker
+ *
+ * Usage:
+ *   const parser = new SSEParser();
+ *   stream.on('data', chunk => {
+ *     const events = parser.parse(chunk);
+ *     events.forEach(event => { ... });
+ *   });
+ */
+class SSEParser {
+  constructor(options = {}) {
+    this.buffer = '';
+    this.eventCount = 0;
+    this.maxBufferSize = options.maxBufferSize || 1024 * 1024; // 1MB default
+  }
+
+  /**
+   * Parse chunk and extract SSE events
+   * @param {Buffer|string} chunk - Data chunk from stream
+   * @returns {Array<Object>} Array of parsed events
+   */
+  parse(chunk) {
+    this.buffer += chunk.toString();
+
+    // C-01 Fix: Prevent unbounded buffer growth (DoS protection)
+    if (this.buffer.length > this.maxBufferSize) {
+      throw new Error(`SSE buffer exceeded ${this.maxBufferSize} bytes (DoS protection)`);
+    }
+
+    const lines = this.buffer.split('\n');
+
+    // Keep incomplete line in buffer
+    this.buffer = lines.pop() || '';
+
+    const events = [];
+    let currentEvent = { event: 'message', data: '' };
+
+    for (const line of lines) {
+      if (line.startsWith('event: ')) {
+        currentEvent.event = line.substring(7).trim();
+      } else if (line.startsWith('data: ')) {
+        const data = line.substring(6);
+
+        if (data === '[DONE]') {
+          this.eventCount++;
+          events.push({
+            event: 'done',
+            data: null,
+            index: this.eventCount
+          });
+          currentEvent = { event: 'message', data: '' };
+        } else {
+          try {
+            currentEvent.data = JSON.parse(data);
+            this.eventCount++;
+            currentEvent.index = this.eventCount;
+            events.push(currentEvent);
+            currentEvent = { event: 'message', data: '' };
+          } catch (e) {
+            // H-01 Fix: Log parse errors for debugging
+            if (typeof console !== 'undefined' && console.error) {
+              console.error('[SSEParser] Malformed JSON event:', e.message, 'Data:', data.substring(0, 100));
+            }
+          }
+        }
+      } else if (line.startsWith('id: ')) {
+        currentEvent.id = line.substring(4).trim();
+      } else if (line.startsWith('retry: ')) {
+        currentEvent.retry = parseInt(line.substring(7), 10);
+      }
+      // Empty lines separate events (already handled by JSON parsing)
+    }
+
+    return events;
+  }
+
+  /**
+   * Reset parser state (for reuse)
+   */
+  reset() {
+    this.buffer = '';
+    this.eventCount = 0;
+  }
+}
+
+module.exports = SSEParser;

package/bin/glmt/task-classifier.js

@@ -0,0 +1,162 @@
+#!/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;

package/bin/{doctor.js → management/doctor.js}

@@ -4,8 +4,8 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { spawn } = require('child_process');
-const { colored } = require('./helpers');
-const { detectClaudeCli } = require('./claude-detector');
+const { colored } = require('../utils/helpers');
+const { detectClaudeCli } = require('../utils/claude-detector');
 
 /**
  * Health check results

package/lib/ccs

@@ -2,7 +2,7 @@
 set -euo pipefail
 
 # Version (updated by scripts/bump-version.sh)
-CCS_VERSION="3.3.0"
+CCS_VERSION="3.4.1"
 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.3.0"
+$CcsVersion = "3.4.1"
 $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.3.0",
+  "version": "3.4.1",
   "description": "Claude Code Switch - Instant profile switching between Claude Sonnet 4.5 and GLM 4.6",
   "keywords": [
     "cli",

package/scripts/dev-install.sh

@@ -0,0 +1,35 @@
+#!/bin/bash
+# Auto-install CCS locally for testing changes
+
+set -e
+
+echo "[CCS Dev Install] Starting..."
+
+# Get to the right directory
+cd "$(dirname "$0")/.."
+
+# Pack the npm package
+echo "[CCS Dev Install] Creating package..."
+npm pack
+
+# Find the tarball
+TARBALL=$(ls -t kaitranntt-ccs-*.tgz | head -1)
+
+if [ -z "$TARBALL" ]; then
+    echo "[CCS Dev Install] ERROR: No tarball found"
+    exit 1
+fi
+
+echo "[CCS Dev Install] Found tarball: $TARBALL"
+
+# Install globally
+echo "[CCS Dev Install] Installing globally..."
+npm install -g "$TARBALL"
+
+# Clean up
+echo "[CCS Dev Install] Cleaning up..."
+rm "$TARBALL"
+
+echo "[CCS Dev Install] ✓ Complete! CCS is now updated."
+echo ""
+echo "Test with: ccs glmt --version"