@kaitranntt/ccs 4.4.0 → 5.0.1

package/bin/delegation/settings-parser.js

@@ -1,109 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-
-/**
- * Parses Claude Code settings for tool restrictions
- */
-class SettingsParser {
-  /**
-   * Parse default permission mode from project settings
-   * @param {string} projectDir - Project directory (usually cwd)
-   * @returns {string} Default permission mode (e.g., 'acceptEdits', 'bypassPermissions', 'plan', 'default')
-   */
-  static parseDefaultPermissionMode(projectDir) {
-    const settings = this._loadSettings(projectDir);
-    const permissions = settings.permissions || {};
-
-    // Priority: local > shared > fallback to 'acceptEdits'
-    const defaultMode = permissions.defaultMode || 'acceptEdits';
-
-    if (process.env.CCS_DEBUG) {
-      console.error(`[i] Permission mode from settings: ${defaultMode}`);
-    }
-
-    return defaultMode;
-  }
-
-  /**
-   * Parse project settings for tool restrictions
-   * @param {string} projectDir - Project directory (usually cwd)
-   * @returns {Object} { allowedTools: string[], disallowedTools: string[] }
-   */
-  static parseToolRestrictions(projectDir) {
-    const settings = this._loadSettings(projectDir);
-    const permissions = settings.permissions || {};
-
-    const allowed = permissions.allow || [];
-    const denied = permissions.deny || [];
-
-    if (process.env.CCS_DEBUG) {
-      console.error(`[i] Tool restrictions: ${allowed.length} allowed, ${denied.length} denied`);
-    }
-
-    return {
-      allowedTools: allowed,
-      disallowedTools: denied
-    };
-  }
-
-  /**
-   * Load and merge settings files (local overrides shared)
-   * @param {string} projectDir - Project directory
-   * @returns {Object} Merged settings
-   * @private
-   */
-  static _loadSettings(projectDir) {
-    const claudeDir = path.join(projectDir, '.claude');
-    const sharedPath = path.join(claudeDir, 'settings.json');
-    const localPath = path.join(claudeDir, 'settings.local.json');
-
-    // Load shared settings
-    const shared = this._readJsonSafe(sharedPath) || {};
-
-    // Load local settings (overrides shared)
-    const local = this._readJsonSafe(localPath) || {};
-
-    // Merge permissions (local overrides shared)
-    return {
-      permissions: {
-        allow: [
-          ...(shared.permissions?.allow || []),
-          ...(local.permissions?.allow || [])
-        ],
-        deny: [
-          ...(shared.permissions?.deny || []),
-          ...(local.permissions?.deny || [])
-        ],
-        // Local defaultMode takes priority over shared
-        defaultMode: local.permissions?.defaultMode || shared.permissions?.defaultMode || null
-      }
-    };
-  }
-
-  /**
-   * Read JSON file safely (no throw)
-   * @param {string} filePath - Path to JSON file
-   * @returns {Object|null} Parsed JSON or null
-   * @private
-   */
-  static _readJsonSafe(filePath) {
-    try {
-      if (!fs.existsSync(filePath)) {
-        return null;
-      }
-
-      const content = fs.readFileSync(filePath, 'utf8');
-      return JSON.parse(content);
-    } catch (error) {
-      if (process.env.CCS_DEBUG) {
-        console.warn(`[!] Failed to read settings: ${filePath}: ${error.message}`);
-      }
-      return null;
-    }
-  }
-}
-
-module.exports = { SettingsParser };

package/bin/glmt/delta-accumulator.js

@@ -1,276 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * DeltaAccumulator - Maintain state across streaming deltas
- *
- * Tracks:
- * - Message metadata (id, model, role)
- * - Content blocks (thinking, text)
- * - Current block index
- * - Accumulated content
- *
- * Usage:
- *   const acc = new DeltaAccumulator(thinkingConfig);
- *   const events = transformer.transformDelta(openaiEvent, acc);
- */
-class DeltaAccumulator {
-  constructor(thinkingConfig = {}, options = {}) {
-    this.thinkingConfig = thinkingConfig;
-    this.messageId = 'msg_' + Date.now() + '_' + Math.random().toString(36).substring(7);
-    this.model = null;
-    this.role = 'assistant';
-
-    // Content blocks
-    this.contentBlocks = [];
-    this.currentBlockIndex = -1;
-
-    // Tool calls tracking
-    this.toolCalls = [];
-    this.toolCallsIndex = {};
-
-    // Buffers
-    this.thinkingBuffer = '';
-    this.textBuffer = '';
-
-    // C-02 Fix: Limits to prevent unbounded accumulation
-    this.maxBlocks = options.maxBlocks || 100;
-    this.maxBufferSize = options.maxBufferSize || 10 * 1024 * 1024; // 10MB
-
-    // Loop detection configuration
-    this.loopDetectionThreshold = options.loopDetectionThreshold || 3;
-    this.loopDetected = false;
-
-    // State flags
-    this.messageStarted = false;
-    this.finalized = false;
-    this.usageReceived = false; // Track if usage data has arrived
-
-    // Statistics
-    this.inputTokens = 0;
-    this.outputTokens = 0;
-    this.finishReason = null;
-  }
-
-  /**
-   * Get current content block
-   * @returns {Object|null} Current block or null
-   */
-  getCurrentBlock() {
-    if (this.currentBlockIndex >= 0 && this.currentBlockIndex < this.contentBlocks.length) {
-      return this.contentBlocks[this.currentBlockIndex];
-    }
-    return null;
-  }
-
-  /**
-   * Start new content block
-   * @param {string} type - Block type ('thinking', 'text', or 'tool_use')
-   * @returns {Object} New block
-   */
-  startBlock(type) {
-    // C-02 Fix: Enforce max blocks limit
-    if (this.contentBlocks.length >= this.maxBlocks) {
-      throw new Error(`Maximum ${this.maxBlocks} content blocks exceeded (DoS protection)`);
-    }
-
-    this.currentBlockIndex++;
-    const block = {
-      index: this.currentBlockIndex,
-      type: type,
-      content: '',
-      started: true,
-      stopped: false
-    };
-    this.contentBlocks.push(block);
-
-    // Reset buffer for new block (tool_use doesn't use buffers)
-    if (type === 'thinking') {
-      this.thinkingBuffer = '';
-    } else if (type === 'text') {
-      this.textBuffer = '';
-    }
-
-    return block;
-  }
-
-  /**
-   * Add delta to current block
-   * @param {string} delta - Content delta
-   */
-  addDelta(delta) {
-    const block = this.getCurrentBlock();
-    if (!block) {
-      // FIX: Guard against null block (should never happen, but defensive)
-      console.error('[DeltaAccumulator] ERROR: addDelta called with no current block');
-      return;
-    }
-
-    if (block.type === 'thinking') {
-      // C-02 Fix: Enforce buffer size limit
-      if (this.thinkingBuffer.length + delta.length > this.maxBufferSize) {
-        throw new Error(`Thinking buffer exceeded ${this.maxBufferSize} bytes (DoS protection)`);
-      }
-      this.thinkingBuffer += delta;
-      block.content = this.thinkingBuffer;
-
-      // FIX: Verify assignment succeeded (paranoid check for race conditions)
-      if (block.content.length !== this.thinkingBuffer.length) {
-        console.error('[DeltaAccumulator] ERROR: Block content assignment failed');
-        console.error(`Expected: ${this.thinkingBuffer.length}, Got: ${block.content.length}`);
-      }
-    } else if (block.type === 'text') {
-      // C-02 Fix: Enforce buffer size limit
-      if (this.textBuffer.length + delta.length > this.maxBufferSize) {
-        throw new Error(`Text buffer exceeded ${this.maxBufferSize} bytes (DoS protection)`);
-      }
-      this.textBuffer += delta;
-      block.content = this.textBuffer;
-    }
-  }
-
-  /**
-   * Mark current block as stopped
-   */
-  stopCurrentBlock() {
-    const block = this.getCurrentBlock();
-    if (block) {
-      block.stopped = true;
-
-      // FIX: Log block closure for debugging (helps diagnose timing issues)
-      if (block.type === 'thinking' && process.env.CCS_DEBUG === '1') {
-        console.error(`[DeltaAccumulator] Stopped thinking block ${block.index}: ${block.content?.length || 0} chars`);
-      }
-    }
-  }
-
-  /**
-   * Update usage statistics
-   * @param {Object} usage - Usage object from OpenAI
-   */
-  updateUsage(usage) {
-    if (usage) {
-      this.inputTokens = usage.prompt_tokens || usage.input_tokens || 0;
-      this.outputTokens = usage.completion_tokens || usage.output_tokens || 0;
-      this.usageReceived = true; // Mark that we've received usage data
-    }
-  }
-
-  /**
-   * Add or update tool call delta
-   * @param {Object} toolCallDelta - Tool call delta from OpenAI
-   */
-  addToolCallDelta(toolCallDelta) {
-    const index = toolCallDelta.index;
-
-    // Initialize tool call if not exists
-    if (!this.toolCallsIndex[index]) {
-      const toolCall = {
-        index: index,
-        id: '',
-        type: 'function',
-        function: {
-          name: '',
-          arguments: ''
-        }
-      };
-      this.toolCalls.push(toolCall);
-      this.toolCallsIndex[index] = toolCall;
-    }
-
-    const toolCall = this.toolCallsIndex[index];
-
-    // Update id if present
-    if (toolCallDelta.id) {
-      toolCall.id = toolCallDelta.id;
-    }
-
-    // Update type if present
-    if (toolCallDelta.type) {
-      toolCall.type = toolCallDelta.type;
-    }
-
-    // Update function name if present
-    if (toolCallDelta.function?.name) {
-      toolCall.function.name += toolCallDelta.function.name;
-    }
-
-    // Update function arguments if present
-    if (toolCallDelta.function?.arguments) {
-      toolCall.function.arguments += toolCallDelta.function.arguments;
-    }
-  }
-
-  /**
-   * Get all tool calls
-   * @returns {Array} Tool calls array
-   */
-  getToolCalls() {
-    return this.toolCalls;
-  }
-
-  /**
-   * Check for planning loop pattern
-   * Loop = N consecutive thinking blocks with no tool calls
-   * @returns {boolean} True if loop detected
-   */
-  checkForLoop() {
-    // Already detected loop
-    if (this.loopDetected) {
-      return true;
-    }
-
-    // Need minimum blocks to detect pattern
-    if (this.contentBlocks.length < this.loopDetectionThreshold) {
-      return false;
-    }
-
-    // Get last N blocks
-    const recentBlocks = this.contentBlocks.slice(-this.loopDetectionThreshold);
-
-    // Check if all recent blocks are thinking blocks
-    const allThinking = recentBlocks.every(b => b.type === 'thinking');
-
-    // Check if no tool calls have been made at all
-    const noToolCalls = this.toolCalls.length === 0;
-
-    // Loop detected if: all recent blocks are thinking AND no tool calls yet
-    if (allThinking && noToolCalls) {
-      this.loopDetected = true;
-      return true;
-    }
-
-    return false;
-  }
-
-  /**
-   * Reset loop detection state (for testing)
-   */
-  resetLoopDetection() {
-    this.loopDetected = false;
-  }
-
-  /**
-   * Get summary of accumulated state
-   * @returns {Object} Summary
-   */
-  getSummary() {
-    return {
-      messageId: this.messageId,
-      model: this.model,
-      role: this.role,
-      blockCount: this.contentBlocks.length,
-      currentIndex: this.currentBlockIndex,
-      toolCallCount: this.toolCalls.length,
-      messageStarted: this.messageStarted,
-      finalized: this.finalized,
-      loopDetected: this.loopDetected,
-      usage: {
-        input_tokens: this.inputTokens,
-        output_tokens: this.outputTokens
-      }
-    };
-  }
-}
-
-module.exports = DeltaAccumulator;