orquesta-cli 0.1.12

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

@@ -0,0 +1,164 @@
+/**
+ * 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

@@ -0,0 +1,25 @@
+/**
+ * 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

@@ -0,0 +1,460 @@
+/**
+ * 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

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