orquesta-cli 0.1.12 → 0.1.14

package/src/core/compact/context-tracker.ts

@@ -1,164 +0,0 @@
-/**
- * Context Tracker
- *
- * Tracks context window usage and determines when auto-compact should trigger.
- * Uses prompt_tokens from LLM API responses to calculate usage.
- */
-
-import { logger } from '../../utils/logger.js';
-
-/**
- * Context usage information
- */
-export interface ContextUsageInfo {
-  /** Last prompt_tokens from API response */
-  currentTokens: number;
-  /** Model's context window size */
-  maxTokens: number;
-  /** Usage percentage (current/max * 100) */
-  usagePercentage: number;
-  /** Remaining percentage (100 - usagePercentage) */
-  remainingPercentage: number;
-  /** Whether auto-compact should trigger */
-  shouldAutoCompact: boolean;
-}
-
-/**
- * Context Tracker Class
- *
- * Singleton that tracks:
- * - Last prompt_tokens from LLM responses
- * - Recent file accesses for compact context
- * - Auto-compact threshold detection
- */
-class ContextTrackerClass {
-  private lastPromptTokens: number = 0;
-  private autoCompactThreshold: number = 70; // percentage
-  private autoCompactTriggered: boolean = false;
-
-  // Recent files tracking
-  private recentFiles: Set<string> = new Set();
-  private maxRecentFiles: number = 20;
-
-  /**
-   * Update usage with prompt_tokens from LLM response
-   */
-  updateUsage(promptTokens: number): void {
-    this.lastPromptTokens = promptTokens;
-    logger.debug('Context usage updated', { promptTokens });
-  }
-
-  /**
-   * Get current context usage information
-   */
-  getContextUsage(modelMaxTokens: number): ContextUsageInfo {
-    const maxTokens = modelMaxTokens || 128000;
-    const usagePercentage = Math.round((this.lastPromptTokens / maxTokens) * 100);
-    const remainingPercentage = Math.max(0, 100 - usagePercentage);
-
-    return {
-      currentTokens: this.lastPromptTokens,
-      maxTokens,
-      usagePercentage,
-      remainingPercentage,
-      shouldAutoCompact: usagePercentage >= this.autoCompactThreshold,
-    };
-  }
-
-  /**
-   * Check if auto-compact should trigger
-   * Returns true only once per threshold crossing (prevents multiple triggers)
-   */
-  shouldTriggerAutoCompact(modelMaxTokens: number): boolean {
-    const usage = this.getContextUsage(modelMaxTokens);
-
-    if (usage.shouldAutoCompact && !this.autoCompactTriggered) {
-      logger.flow('Auto-compact threshold reached');
-      logger.vars(
-        { name: 'usagePercentage', value: usage.usagePercentage },
-        { name: 'threshold', value: this.autoCompactThreshold }
-      );
-      this.autoCompactTriggered = true;
-      return true;
-    }
-
-    return false;
-  }
-
-  /**
-   * Reset after compact (allow future auto-compact triggers)
-   * @param estimatedTokens Optional estimated token count for compacted messages
-   */
-  reset(estimatedTokens?: number): void {
-    logger.flow('ContextTracker reset', { estimatedTokens });
-    // If estimatedTokens provided, use it; otherwise calculate from 0
-    // This ensures UI shows approximate usage after compact
-    this.lastPromptTokens = estimatedTokens ?? 0;
-    this.autoCompactTriggered = false;
-    this.recentFiles.clear();
-  }
-
-  /**
-   * Estimate token count from text (rough approximation: ~4 chars per token)
-   */
-  estimateTokens(text: string): number {
-    return Math.ceil(text.length / 4);
-  }
-
-  /**
-   * Reset only the auto-compact trigger flag
-   * Call this after processing a message to allow future triggers
-   */
-  resetAutoCompactTrigger(): void {
-    this.autoCompactTriggered = false;
-  }
-
-  /**
-   * Track file access for compact context
-   */
-  trackFileAccess(filePath: string): void {
-    this.recentFiles.add(filePath);
-
-    // Keep only last N files
-    if (this.recentFiles.size > this.maxRecentFiles) {
-      const arr = Array.from(this.recentFiles);
-      this.recentFiles = new Set(arr.slice(-this.maxRecentFiles));
-    }
-  }
-
-  /**
-   * Get recently accessed files
-   */
-  getRecentFiles(): string[] {
-    return Array.from(this.recentFiles);
-  }
-
-  /**
-   * Get the auto-compact threshold percentage
-   */
-  getThreshold(): number {
-    return this.autoCompactThreshold;
-  }
-
-  /**
-   * Set the auto-compact threshold percentage
-   */
-  setThreshold(threshold: number): void {
-    if (threshold > 0 && threshold <= 100) {
-      logger.state('Auto-compact threshold', this.autoCompactThreshold, threshold);
-      this.autoCompactThreshold = threshold;
-    }
-  }
-
-  /**
-   * Get last prompt tokens
-   */
-  getLastPromptTokens(): number {
-    return this.lastPromptTokens;
-  }
-}
-
-// Singleton instance
-export const contextTracker = new ContextTrackerClass();
-
-export default contextTracker;

package/src/core/compact/index.ts

@@ -1,25 +0,0 @@
-/**
- * Compact Module
- *
- * Provides auto-compact functionality for managing context window usage.
- */
-
-// Context tracking
-export {
-  contextTracker,
-  type ContextUsageInfo,
-} from './context-tracker.js';
-
-// Compact prompts and utilities
-export {
-  COMPACT_SYSTEM_PROMPT,
-  buildCompactUserPrompt,
-  buildCompactedMessages,
-  type CompactContext,
-} from './compact-prompts.js';
-
-// Compact manager
-export {
-  CompactManager,
-  type CompactResult,
-} from './compact-manager.js';

package/src/core/config/config-manager.ts

@@ -1,460 +0,0 @@
-/**
- * Configuration Manager
- *
- * LOCAL-CLI configuration management system
- * Manages ~/.local-cli/ directory and configuration files
- */
-
-import { OpenConfig, EndpointConfig, ModelInfo } from '../../types/index.js';
-import {
-  OPEN_HOME_DIR,
-  CONFIG_FILE_PATH,
-  DOCS_DIR,
-  BACKUPS_DIR,
-  PROJECTS_DIR,
-} from '../../constants.js';
-import {
-  ensureDirectory,
-  readJsonFile,
-  writeJsonFile,
-  directoryExists,
-} from '../../utils/file-system.js';
-import { logger } from '../../utils/logger.js';
-
-/**
- * Default configuration (empty endpoint)
- */
-const DEFAULT_CONFIG: OpenConfig = {
-  version: '0.1.0',
-  currentEndpoint: undefined,
-  currentModel: undefined,
-  endpoints: [],
-  settings: {
-    autoApprove: false,
-    debugMode: false,
-    streamResponse: true,
-    autoSave: true,
-  },
-  safeEnvVars: [], // User can add env vars they want to pass to subprocesses
-};
-
-/**
- * ConfigManager class
- *
- * Configuration file and directory management
- */
-export class ConfigManager {
-  private config: OpenConfig | null = null;
-  private initialized = false;
-
-  /**
-   * Initialize LOCAL-CLI
-   * Create ~/.local-cli/ directory and configuration file
-   */
-  async initialize(): Promise<void> {
-    logger.enter('ConfigManager.initialize');
-    if (this.initialized) {
-      logger.flow('ConfigManager already initialized');
-      return;
-    }
-
-    // Create home directory
-    await ensureDirectory(OPEN_HOME_DIR);
-
-    // Create subdirectories
-    await ensureDirectory(DOCS_DIR);
-    await ensureDirectory(BACKUPS_DIR);
-    await ensureDirectory(PROJECTS_DIR);
-
-    // Load or create configuration file
-    await this.loadOrCreateConfig();
-
-    this.initialized = true;
-    logger.exit('ConfigManager.initialize', { success: true });
-  }
-
-  /**
-   * Load configuration file or create default configuration
-   */
-  private async loadOrCreateConfig(): Promise<void> {
-    const existingConfig = await readJsonFile<OpenConfig>(CONFIG_FILE_PATH);
-
-    if (existingConfig) {
-      this.config = existingConfig;
-    } else {
-      // Create default configuration
-      this.config = { ...DEFAULT_CONFIG };
-      await this.saveConfig();
-    }
-  }
-
-  /**
-   * Save configuration
-   */
-  async saveConfig(): Promise<void> {
-    if (!this.config) {
-      const error = new Error('Configuration not initialized');
-      logger.error('Config save failed', error);
-      throw error;
-    }
-
-    logger.flow('Saving configuration');
-    await writeJsonFile(CONFIG_FILE_PATH, this.config);
-  }
-
-  /**
-   * Get current configuration
-   */
-  getConfig(): OpenConfig {
-    if (!this.config) {
-      throw new Error('Configuration not initialized. Call initialize() first.');
-    }
-
-    return this.config;
-  }
-
-  /**
-   * Get current endpoint
-   */
-  getCurrentEndpoint(): EndpointConfig | null {
-    const config = this.getConfig();
-
-    if (!config.currentEndpoint) {
-      return null;
-    }
-
-    return config.endpoints.find((ep) => ep.id === config.currentEndpoint) || null;
-  }
-
-  /**
-   * Get current model information
-   */
-  getCurrentModel(): ModelInfo | null {
-    const endpoint = this.getCurrentEndpoint();
-
-    if (!endpoint || !this.config?.currentModel) {
-      return null;
-    }
-
-    return endpoint.models.find((m) => m.id === this.config?.currentModel) || null;
-  }
-
-  /**
-   * Get all endpoints
-   */
-  getAllEndpoints(): EndpointConfig[] {
-    return this.getConfig().endpoints;
-  }
-
-  /**
-   * Add endpoint
-   */
-  async addEndpoint(endpoint: EndpointConfig): Promise<void> {
-    const config = this.getConfig();
-
-    // Check for duplicate ID
-    const exists = config.endpoints.some((ep) => ep.id === endpoint.id);
-    if (exists) {
-      throw new Error(`Endpoint with ID ${endpoint.id} already exists`);
-    }
-
-    config.endpoints.push(endpoint);
-    await this.saveConfig();
-  }
-
-  /**
-   * Delete endpoint
-   */
-  async removeEndpoint(endpointId: string): Promise<void> {
-    const config = this.getConfig();
-
-    config.endpoints = config.endpoints.filter((ep) => ep.id !== endpointId);
-
-    // If current endpoint is deleted, switch to first endpoint (or undefined)
-    if (config.currentEndpoint === endpointId) {
-      const firstEndpoint = config.endpoints[0];
-      config.currentEndpoint = firstEndpoint?.id;
-
-      // Switch to first model of first endpoint
-      if (firstEndpoint) {
-        const firstModel = firstEndpoint.models.find((m) => m.enabled);
-        config.currentModel = firstModel?.id;
-      } else {
-        config.currentModel = undefined;
-      }
-    }
-
-    await this.saveConfig();
-  }
-
-  /**
-   * Change current endpoint
-   */
-  async setCurrentEndpoint(endpointId: string): Promise<void> {
-    const config = this.getConfig();
-
-    const endpoint = config.endpoints.find((ep) => ep.id === endpointId);
-    if (!endpoint) {
-      throw new Error(`Endpoint ${endpointId} not found`);
-    }
-
-    config.currentEndpoint = endpointId;
-
-    // Switch to first active model of that endpoint
-    const activeModel = endpoint.models.find((m) => m.enabled);
-    if (activeModel) {
-      config.currentModel = activeModel.id;
-    }
-
-    await this.saveConfig();
-  }
-
-  /**
-   * Change current model
-   */
-  async setCurrentModel(modelId: string): Promise<void> {
-    const config = this.getConfig();
-    const endpoint = this.getCurrentEndpoint();
-
-    if (!endpoint) {
-      throw new Error('No endpoint selected');
-    }
-
-    const model = endpoint.models.find((m) => m.id === modelId);
-    if (!model) {
-      throw new Error(`Model ${modelId} not found in current endpoint`);
-    }
-
-    if (!model.enabled) {
-      throw new Error(`Model ${modelId} is disabled`);
-    }
-
-    config.currentModel = modelId;
-    await this.saveConfig();
-  }
-
-  /**
-   * Update configuration value
-   */
-  async updateSettings(settings: Partial<OpenConfig['settings']>): Promise<void> {
-    const config = this.getConfig();
-    config.settings = { ...config.settings, ...settings };
-    await this.saveConfig();
-  }
-
-  /**
-   * Get user-defined safe environment variables
-   * These are additional env vars the user trusts to pass to subprocesses
-   */
-  getSafeEnvVars(): string[] {
-    const config = this.getConfig();
-    return config.safeEnvVars || [];
-  }
-
-  /**
-   * Check if home directory exists
-   */
-  async isInitialized(): Promise<boolean> {
-    return await directoryExists(OPEN_HOME_DIR);
-  }
-
-  /**
-   * Check if endpoint exists
-   */
-  hasEndpoints(): boolean {
-    if (!this.config) {
-      return false;
-    }
-    return this.config.endpoints.length > 0;
-  }
-
-  /**
-   * Create initial endpoint
-   * Add first endpoint and automatically set as current endpoint/model
-   */
-  async createInitialEndpoint(endpoint: EndpointConfig): Promise<void> {
-    const config = this.getConfig();
-
-    // Add first endpoint
-    config.endpoints.push(endpoint);
-
-    // Automatically set as current endpoint/model
-    config.currentEndpoint = endpoint.id;
-
-    // Set first active model as current model
-    const activeModel = endpoint.models.find((m) => m.enabled);
-    if (activeModel) {
-      config.currentModel = activeModel.id;
-    }
-
-    await this.saveConfig();
-  }
-
-  /**
-   * Reset configuration (factory reset)
-   */
-  async reset(): Promise<void> {
-    this.config = { ...DEFAULT_CONFIG };
-    await this.saveConfig();
-  }
-
-  /**
-   * Update endpoint
-   */
-  async updateEndpoint(
-    endpointId: string,
-    updates: Partial<Omit<EndpointConfig, 'id' | 'createdAt'>>
-  ): Promise<void> {
-    const config = this.getConfig();
-    const endpointIndex = config.endpoints.findIndex((ep) => ep.id === endpointId);
-
-    if (endpointIndex === -1) {
-      throw new Error(`Endpoint ${endpointId} not found`);
-    }
-
-    const endpoint = config.endpoints[endpointIndex]!;
-    config.endpoints[endpointIndex] = {
-      ...endpoint,
-      ...updates,
-      updatedAt: new Date(),
-    };
-
-    await this.saveConfig();
-  }
-
-  /**
-   * Update model health status
-   */
-  async updateModelHealth(
-    endpointId: string,
-    modelId: string,
-    status: 'healthy' | 'degraded' | 'unhealthy',
-    _latency?: number
-  ): Promise<void> {
-    const config = this.getConfig();
-    const endpoint = config.endpoints.find((ep) => ep.id === endpointId);
-
-    if (!endpoint) {
-      throw new Error(`Endpoint ${endpointId} not found`);
-    }
-
-    const model = endpoint.models.find((m) => m.id === modelId);
-    if (!model) {
-      throw new Error(`Model ${modelId} not found in endpoint ${endpointId}`);
-    }
-
-    model.healthStatus = status;
-    model.lastHealthCheck = new Date();
-
-    await this.saveConfig();
-  }
-
-  /**
-   * Bulk update health status of all models
-   */
-  async updateAllHealthStatus(
-    healthResults: Map<string, { modelId: string; healthy: boolean; latency?: number }[]>
-  ): Promise<void> {
-    const config = this.getConfig();
-
-    for (const [endpointId, modelResults] of healthResults) {
-      const endpoint = config.endpoints.find((ep) => ep.id === endpointId);
-      if (!endpoint) continue;
-
-      for (const result of modelResults) {
-        const model = endpoint.models.find((m) => m.id === result.modelId);
-        if (model) {
-          model.healthStatus = result.healthy ? 'healthy' : 'unhealthy';
-          model.lastHealthCheck = new Date();
-        }
-      }
-    }
-
-    await this.saveConfig();
-  }
-
-  /**
-   * Query list of all healthy models
-   */
-  getHealthyModels(): { endpoint: EndpointConfig; model: ModelInfo }[] {
-    const config = this.getConfig();
-    const healthyModels: { endpoint: EndpointConfig; model: ModelInfo }[] = [];
-
-    for (const endpoint of config.endpoints) {
-      for (const model of endpoint.models) {
-        if (model.enabled && model.healthStatus === 'healthy') {
-          healthyModels.push({ endpoint, model });
-        }
-      }
-    }
-
-    return healthyModels;
-  }
-
-  /**
-   * Query all model list (including endpoint information)
-   */
-  getAllModels(): { endpoint: EndpointConfig; model: ModelInfo; isCurrent: boolean }[] {
-    const config = this.getConfig();
-    const allModels: { endpoint: EndpointConfig; model: ModelInfo; isCurrent: boolean }[] = [];
-
-    for (const endpoint of config.endpoints) {
-      for (const model of endpoint.models) {
-        const isCurrent =
-          endpoint.id === config.currentEndpoint && model.id === config.currentModel;
-        allModels.push({ endpoint, model, isCurrent });
-      }
-    }
-
-    return allModels;
-  }
-
-  /**
-   * Get enabled tool group IDs
-   */
-  getEnabledTools(): string[] {
-    const config = this.getConfig();
-    return config.enabledTools || [];
-  }
-
-  /**
-   * Set enabled tool group IDs
-   */
-  async setEnabledTools(toolIds: string[]): Promise<void> {
-    const config = this.getConfig();
-    config.enabledTools = toolIds;
-    await this.saveConfig();
-  }
-
-  /**
-   * Enable a tool group
-   */
-  async enableTool(toolId: string): Promise<void> {
-    const config = this.getConfig();
-    const enabledTools = config.enabledTools || [];
-    if (!enabledTools.includes(toolId)) {
-      enabledTools.push(toolId);
-      config.enabledTools = enabledTools;
-      await this.saveConfig();
-    }
-  }
-
-  /**
-   * Disable a tool group
-   */
-  async disableTool(toolId: string): Promise<void> {
-    const config = this.getConfig();
-    const enabledTools = config.enabledTools || [];
-    const index = enabledTools.indexOf(toolId);
-    if (index !== -1) {
-      enabledTools.splice(index, 1);
-      config.enabledTools = enabledTools;
-      await this.saveConfig();
-    }
-  }
-}
-
-/**
- * ConfigManager singleton instance
- */
-export const configManager = new ConfigManager();

package/src/core/config/index.ts

@@ -1,5 +0,0 @@
-/**
- * Config module barrel export
- */
-
-export * from './config-manager.js';