ctxman 3.0.0 → 3.1.1

package/lib/utils/llm-detector.js

@@ -19,6 +19,12 @@ let profilesCache = null;
 // Logger instance
 const logger = getLogger('LLMDetector');
 
+/** Model used when nothing is configured or detected (a current, widely available model) */
+export const DEFAULT_TARGET_MODEL = 'claude-sonnet-5-5';
+
+// Deprecated/retired notices already printed in this process
+const warnedModels = new Set();
+
 export class LLMDetector {
   /**
    * Load LLM profiles from JSON config
@@ -37,6 +43,7 @@ export class LLMDetector {
       const profilesData = JSON.parse(readFileSync(profilesPath, 'utf-8'));
       const builtInProfiles = profilesData.profiles || {};
       const defaultProfile = profilesData.default;
+      let aliases = profilesData.aliases || {};
 
       // Try to load custom profiles
       let customProfiles = {};
@@ -44,8 +51,9 @@ export class LLMDetector {
         const customPath = resolve(__dirname, '../../.ctxman/custom-profiles.json');
         const customData = JSON.parse(readFileSync(customPath, 'utf-8'));
         customProfiles = customData.profiles || {};
+        aliases = { ...aliases, ...(customData.aliases || {}) };
         logger.debug(`Loaded ${Object.keys(customProfiles).length} custom LLM profiles`);
-      } catch (error) {
+      } catch (_error) {
         // Custom profiles optional
         logger.debug('No custom profiles found (optional)');
       }
@@ -53,51 +61,44 @@ export class LLMDetector {
       // Merge profiles (custom overrides built-in)
       const allProfiles = {
         ...builtInProfiles,
-        ...customProfiles
+        ...customProfiles,
       };
 
       // Cache the result
       profilesCache = {
         profiles: allProfiles,
-        default: defaultProfile
+        default: defaultProfile,
+        aliases,
+        lastUpdated: profilesData.lastUpdated,
       };
 
       logger.debug(`Loaded ${Object.keys(allProfiles).length} total LLM profiles`);
       return profilesCache;
-
     } catch (error) {
       logger.error(`Failed to load LLM profiles: ${error.message}`);
 
       // Fallback to minimal built-in if JSON load fails
       const fallback = {
         profiles: {
-          'claude-sonnet-4.5': {
-            name: 'Claude Sonnet 4.5',
+          [DEFAULT_TARGET_MODEL]: {
+            name: 'Claude Sonnet 5.5',
             vendor: 'Anthropic',
-            contextWindow: 200000,
+            contextWindow: 1000000,
             utilizationPercentage: 0.6,
-            maxRecommendedInput: 120000,
+            maxRecommendedInput: 600000,
             preferredFormat: 'toon',
-            chunkStrategy: 'smart'
+            chunkStrategy: 'none',
           },
-          'gpt-4o': {
-            name: 'GPT-4o',
-            vendor: 'OpenAI',
-            contextWindow: 128000,
-            utilizationPercentage: 0.6,
-            maxRecommendedInput: 76800,
-            preferredFormat: 'json',
-            chunkStrategy: 'smart'
-          }
         },
+        aliases: {},
         default: {
           name: 'Unknown Model',
           contextWindow: 100000,
           utilizationPercentage: 0.6,
           maxRecommendedInput: 60000,
           preferredFormat: 'json',
-          chunkStrategy: 'smart'
-        }
+          chunkStrategy: 'smart',
+        },
       };
 
       profilesCache = fallback;
@@ -114,6 +115,14 @@ export class LLMDetector {
     return data.default;
   }
 
+  /**
+   * Id of the model used when none is configured
+   * @returns {string}
+   */
+  static getDefaultModelId() {
+    return DEFAULT_TARGET_MODEL;
+  }
+
   /**
    * Get all profiles
    * @returns {object} All LLM profiles
@@ -147,7 +156,6 @@ export class LLMDetector {
 
       logger.debug('No LLM detected, using defaults');
       return 'unknown';
-
     } finally {
       const elapsed = Date.now() - startTime;
       if (elapsed > 100) {
@@ -169,24 +177,21 @@ export class LLMDetector {
       return process.env.CTXMAN_LLM;
     }
 
-    // Anthropic (Claude)
+    // A provider's API key selects that provider's current balanced model
     if (process.env.ANTHROPIC_API_KEY) {
-      return 'claude-sonnet-4.5'; // Default to Sonnet
+      return 'claude-sonnet-5-5';
     }
 
-    // OpenAI (GPT-4)
     if (process.env.OPENAI_API_KEY) {
-      return 'gpt-4o'; // Default to GPT-4o (most capable)
+      return 'gpt-6.1-sol';
     }
 
-    // Google (Gemini)
     if (process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY) {
-      return 'gemini-2.0-flash'; // Default to Flash (fastest)
+      return 'gemini-3.8-flash';
     }
 
-    // DeepSeek
     if (process.env.DEEPSEEK_API_KEY) {
-      return 'deepseek-chat'; // Default to Chat
+      return 'deepseek-flash';
     }
 
     return null;
@@ -220,22 +225,60 @@ export class LLMDetector {
       return this.getDefaultProfile();
     }
 
-    // Load all profiles
-    const allProfiles = this.getAllProfiles();
-
-    // Check if profile exists
-    if (allProfiles[modelName]) {
-      return allProfiles[modelName];
+    const id = this.resolveModelId(modelName);
+    if (id) {
+      const profile = { id, ...this.getAllProfiles()[id] };
+      this.warnIfOutdated(profile);
+      return profile;
     }
 
     // Fallback to default
-    logger.warn(`Unknown LLM model: ${modelName}, using default profile`);
+    logger.warn(`Unknown LLM model: ${modelName}, using default profile (see --list-llms)`);
     return {
       ...this.getDefaultProfile(),
-      name: modelName
+      name: modelName,
     };
   }
 
+  /**
+   * Map a model name to the id of its profile: the id itself, an alias (older ctxman
+   * ids such as `claude-sonnet-4.5`, provider aliases) or a dated snapshot id
+   * (`claude-haiku-4-5-20251001`, `gpt-5-2025-08-07`)
+   * @param {string} modelName - Model identifier as given by the user
+   * @returns {string|null} Profile id, or null for unknown models
+   */
+  static resolveModelId(modelName) {
+    if (!modelName) return null;
+    const { profiles, aliases = {} } = this.loadProfiles();
+    const candidates = [modelName, modelName.toLowerCase()];
+    for (const name of candidates) {
+      if (profiles[name]) return name;
+      if (aliases[name] && profiles[aliases[name]]) return aliases[name];
+    }
+    const undated = modelName
+      .toLowerCase()
+      .replace(/-\d{4}-\d{2}-\d{2}$/, '')
+      .replace(/-\d{8}$/, '');
+    if (undated !== modelName.toLowerCase()) {
+      return this.resolveModelId(undated);
+    }
+    return null;
+  }
+
+  /**
+   * Warn once per process when a profile's model is deprecated or retired by its provider
+   * @param {object} profile - Resolved profile (with id)
+   */
+  static warnIfOutdated(profile) {
+    if (!['deprecated', 'retired'].includes(profile.status) || warnedModels.has(profile.id)) {
+      return;
+    }
+    warnedModels.add(profile.id);
+    const when = profile.retires ? ` (retires ${profile.retires})` : '';
+    const instead = profile.replacement ? `; consider ${profile.replacement}` : '';
+    logger.warn(`${profile.name} is ${profile.status} by ${profile.vendor}${when}${instead}`);
+  }
+
   /**
    * Recommend optimal configuration based on LLM profile and repository stats
    * @param {object} profile - LLM profile
@@ -243,7 +286,7 @@ export class LLMDetector {
    * @returns {object} Configuration recommendations
    */
   static recommendConfiguration(profile, repoStats) {
-    const { totalTokens, totalFiles } = repoStats;
+    const { totalTokens } = repoStats;
     const { maxRecommendedInput, preferredFormat, chunkStrategy, utilizationPercentage } = profile;
 
     const fitsInContext = totalTokens <= maxRecommendedInput;
@@ -261,7 +304,7 @@ export class LLMDetector {
       chunksNeeded: chunksNeeded,
       fitsInContext: fitsInContext,
       utilizationPercentage: Math.round((utilizationPercentage || 0.6) * 100),
-      utilizationActual: (totalTokens / maxRecommendedInput) * 100
+      utilizationActual: (totalTokens / maxRecommendedInput) * 100,
     };
   }
 
@@ -269,9 +312,10 @@ export class LLMDetector {
    * Analyze context fit - detailed analysis for display
    * @param {object} profile - LLM profile
    * @param {object} repoStats - Repository statistics
+   * @param {object[]} largestFiles - Optional array of largest files for suggestions
    * @returns {object} Context fit analysis
    */
-  static analyzeContextFit(profile, repoStats) {
+  static analyzeContextFit(profile, repoStats, largestFiles = []) {
     const { totalTokens, totalFiles } = repoStats;
     const { name, contextWindow, maxRecommendedInput, utilizationPercentage } = profile;
 
@@ -284,6 +328,22 @@ export class LLMDetector {
     const chunksNeeded = fitsInOne ? 1 : Math.ceil(totalTokens / usableContext);
     const utilizationActual = (totalTokens / usableContext) * 100; // % of usable context
 
+    // Calculate percentage of total context window
+    const percentageOfTotal = (totalTokens / contextWindow) * 100;
+
+    // Determine warning level based on thresholds
+    let warningLevel = 'ok';
+    if (percentageOfTotal >= 100) {
+      warningLevel = 'overflow';
+    } else if (percentageOfTotal >= 90) {
+      warningLevel = 'critical';
+    } else if (percentageOfTotal >= 80) {
+      warningLevel = 'warning';
+    }
+
+    // Generate file suggestions if needed
+    const suggestions = this.generateFileSuggestions(largestFiles, totalTokens, usableContext);
+
     return {
       modelName: name,
       contextWindow,
@@ -295,10 +355,88 @@ export class LLMDetector {
       fitsInOne,
       chunksNeeded,
       utilizationActual,
-      recommendation: this.getRecommendation(fitsInOne, chunksNeeded, utilizationActual)
+      percentageOfTotal,
+      warningLevel,
+      suggestions,
+      recommendation: this.getRecommendation(fitsInOne, chunksNeeded, utilizationActual),
     };
   }
 
+  /**
+   * Generate file exclusion suggestions based on largest files
+   * @param {object[]} largestFiles - Array of largest files sorted by tokens
+   * @param {number} totalTokens - Total repository tokens
+   * @param {number} usableContext - Usable context limit
+   * @returns {object[]} Array of file suggestions
+   */
+  static generateFileSuggestions(largestFiles, totalTokens, usableContext) {
+    if (!largestFiles || largestFiles.length === 0) {
+      return [];
+    }
+
+    const suggestions = [];
+    const excessTokens = totalTokens - usableContext;
+
+    // If we're over budget, suggest files to exclude
+    if (excessTokens > 0) {
+      let accumulatedSavings = 0;
+
+      for (const file of largestFiles) {
+        if (accumulatedSavings >= excessTokens) break;
+
+        suggestions.push({
+          path: file.relativePath || file.path,
+          tokens: file.tokens,
+          percentage: ((file.tokens / totalTokens) * 100).toFixed(1),
+          reason: this.getFileSuggestionReason(file),
+        });
+
+        accumulatedSavings += file.tokens;
+      }
+    } else {
+      // Even if under budget, show top files that could be excluded if needed
+      const topFiles = largestFiles.slice(0, 3);
+      for (const file of topFiles) {
+        suggestions.push({
+          path: file.relativePath || file.path,
+          tokens: file.tokens,
+          percentage: ((file.tokens / totalTokens) * 100).toFixed(1),
+          reason: this.getFileSuggestionReason(file),
+        });
+      }
+    }
+
+    return suggestions;
+  }
+
+  /**
+   * Determine reason for file suggestion
+   * @param {object} file - File info object
+   * @returns {string} Suggestion reason
+   */
+  static getFileSuggestionReason(file) {
+    const path = file.relativePath || file.path;
+    const ext = path.split('.').pop()?.toLowerCase();
+
+    if (path.includes('.test.') || path.includes('.spec.') || path.includes('__tests__')) {
+      return 'Test file';
+    }
+    if (path.includes('node_modules')) {
+      return 'Dependency';
+    }
+    if (ext === 'md' || path.includes('docs/') || path.includes('documentation/')) {
+      return 'Documentation';
+    }
+    if (ext === 'json' && !path.includes('package.json') && !path.includes('tsconfig.json')) {
+      return 'Data file';
+    }
+    if (path.includes('dist/') || path.includes('build/') || path.includes('coverage/')) {
+      return 'Build output';
+    }
+
+    return 'Large file';
+  }
+
   /**
    * Get recommendation message based on context fit
    * @param {boolean} fitsInOne - Whether repo fits in one context
@@ -340,17 +478,32 @@ export class LLMDetector {
 
   /**
    * Get human-readable list of models with details
+   * @param {object} [options]
+   * @param {boolean} [options.includeRetired=false] - Also list models the provider has retired
    * @returns {object[]} Array of model details
    */
-  static getModelList() {
+  static getModelList({ includeRetired = false } = {}) {
     const allProfiles = this.getAllProfiles();
-    return Object.entries(allProfiles).map(([key, profile]) => ({
-      id: key,
-      name: profile.name,
-      vendor: profile.vendor,
-      contextWindow: profile.contextWindow,
-      preferredFormat: profile.preferredFormat
-    }));
+    return Object.entries(allProfiles)
+      .filter(([, profile]) => includeRetired || profile.status !== 'retired')
+      .map(([key, profile]) => ({
+        id: key,
+        name: profile.name,
+        vendor: profile.vendor,
+        contextWindow: profile.contextWindow,
+        outputWindow: profile.outputWindow,
+        preferredFormat: profile.preferredFormat,
+        status: profile.status || 'active',
+        pricing: profile.pricing || null,
+      }));
+  }
+
+  /**
+   * Date the built-in model data was last checked against the providers' docs
+   * @returns {string|undefined} ISO date
+   */
+  static getDataDate() {
+    return this.loadProfiles().lastUpdated;
   }
 
   /**
@@ -365,43 +518,54 @@ export class LLMDetector {
     lines.push('📊 Context Window Analysis:');
     lines.push('════════════════════════════════════════════════════');
     lines.push(`   Target Model: ${analysis.modelName}`);
-    lines.push(`   Total Context: ${analysis.contextWindow.toLocaleString()} tokens`);
-    lines.push(`   Usable Context: ${analysis.usableContext.toLocaleString()} tokens (${analysis.utilizationPercentage}% policy)`);
-    lines.push(`   Reserved for System: ${analysis.reservedForSystem.toLocaleString()} tokens (${100 - analysis.utilizationPercentage}%)`);
+    lines.push(`   Available Context: ${analysis.contextWindow.toLocaleString()} tokens`);
+
+    // Show actual percentage of total context window
+    const percentageDisplay = analysis.percentageOfTotal.toFixed(1);
+    lines.push(
+      `   Your Repository: ${analysis.repoTokens.toLocaleString()} tokens (${percentageDisplay}%)`
+    );
     lines.push('');
-    lines.push(`   Your Repository: ${analysis.repoTokens.toLocaleString()} tokens (${analysis.repoFiles} files)`);
 
-    if (analysis.fitsInOne) {
-      // Show utilization only if it fits
-      lines.push(`   Utilization: ${analysis.utilizationActual.toFixed(1)}% of usable context`);
+    // Warning level display with colors (using ANSI codes)
+    if (analysis.warningLevel === 'overflow') {
+      // Red for overflow (100%+)
+      lines.push("   \x1b[31m⚠️  OVERFLOW: You've exceeded the context window!\x1b[0m");
+      lines.push(
+        `   Exceeds by: ${(analysis.repoTokens - analysis.contextWindow).toLocaleString()} tokens`
+      );
+    } else if (analysis.warningLevel === 'critical') {
+      // Red for critical (90-99%)
+      lines.push("   \x1b[31m⚠️  CRITICAL: You're using 90%+ of context window\x1b[0m");
+    } else if (analysis.warningLevel === 'warning') {
+      // Yellow for warning (80-89%)
+      lines.push("   \x1b[33m⚠️  WARNING: You're using 80%+ of context window\x1b[0m");
+    } else {
+      // Green for OK
+      lines.push('   \x1b[32m✅ Context usage is within safe limits\x1b[0m');
+    }
+
+    // Show suggestions if available
+    if (analysis.suggestions && analysis.suggestions.length > 0) {
       lines.push('');
+      lines.push('   💡 Consider excluding these large files:');
 
-      // Determine fit quality
-      let fitStatus = '';
-      if (analysis.utilizationActual < 50) {
-        fitStatus = '✅ EXCELLENT FIT!';
-      } else if (analysis.utilizationActual < 80) {
-        fitStatus = '✅ GOOD FIT!';
-      } else {
-        fitStatus = '⚠️  ACCEPTABLE FIT';
-      }
+      const maxSuggestions = analysis.warningLevel === 'overflow' ? 5 : 3;
+      const suggestionsToShow = analysis.suggestions.slice(0, maxSuggestions);
 
-      lines.push(`   ${fitStatus}`);
-      lines.push(`   ${analysis.recommendation}`);
-      lines.push('   💡 Recommendation: Use single-file export (no chunking needed)');
-    } else {
-      // Show excess instead of percentage over 100%
-      const excess = analysis.repoTokens - analysis.usableContext;
-      const excessMultiplier = (analysis.repoTokens / analysis.usableContext).toFixed(1);
+      for (const suggestion of suggestionsToShow) {
+        lines.push(
+          `      - ${suggestion.path} (${suggestion.tokens.toLocaleString()} tokens, ${suggestion.percentage}%)`
+        );
+      }
 
-      lines.push(`   Exceeds by: ${excess.toLocaleString()} tokens (${excessMultiplier}x usable context)`);
-      lines.push('');
-      lines.push(`   ❌ TOO LARGE! Repository exceeds usable context.`);
-      lines.push(`   📦 Chunks Needed: ${analysis.chunksNeeded}`);
-      lines.push('   💡 Recommendation: Enable chunking with --chunk flag');
-      lines.push(`   💡 Or: Filter files with .contextinclude to fit in ${analysis.usableContext.toLocaleString()} tokens`);
+      if (analysis.suggestions.length > maxSuggestions) {
+        lines.push(`      ... and ${analysis.suggestions.length - maxSuggestions} more`);
+      }
     }
 
+    lines.push('');
+    lines.push(`   ${analysis.recommendation}`);
     lines.push('');
 
     return lines.join('\n');