@git.zone/tsdoc 1.11.0 → 1.11.2

package/ts/context/context-trimmer.ts

@@ -1,310 +0,0 @@
-import * as plugins from '../plugins.js';
-import type { ITrimConfig, ContextMode } from './types.js';
-
-/**
- * Class responsible for trimming file contents to reduce token usage
- * while preserving important information for context
- */
-export class ContextTrimmer {
-  private config: ITrimConfig;
-  
-  /**
-   * Create a new ContextTrimmer with the given configuration
-   * @param config The trimming configuration
-   */
-  constructor(config?: ITrimConfig) {
-    this.config = {
-      removeImplementations: true,
-      preserveInterfaces: true,
-      preserveTypeDefs: true,
-      preserveJSDoc: true,
-      maxFunctionLines: 5,
-      removeComments: true,
-      removeBlankLines: true,
-      ...config
-    };
-  }
-  
-  /**
-   * Trim a file's contents based on the configuration
-   * @param filePath The path to the file
-   * @param content The file's contents
-   * @param mode The context mode to use
-   * @returns The trimmed file contents
-   */
-  public trimFile(filePath: string, content: string, mode: ContextMode = 'trimmed'): string {
-    // If mode is 'full', return the original content
-    if (mode === 'full') {
-      return content;
-    }
-    
-    // Process based on file type
-    if (filePath.endsWith('.ts') || filePath.endsWith('.tsx')) {
-      return this.trimTypeScriptFile(content);
-    } else if (filePath.endsWith('.md')) {
-      return this.trimMarkdownFile(content);
-    } else if (filePath.endsWith('.json')) {
-      return this.trimJsonFile(content);
-    }
-    
-    // Default to returning the original content for unknown file types
-    return content;
-  }
-  
-  /**
-   * Trim a TypeScript file to reduce token usage
-   * @param content The TypeScript file contents
-   * @returns The trimmed file contents
-   */
-  private trimTypeScriptFile(content: string): string {
-    let result = content;
-    
-    // Step 1: Preserve JSDoc comments if configured
-    const jsDocComments: string[] = [];
-    if (this.config.preserveJSDoc) {
-      const jsDocRegex = /\/\*\*[\s\S]*?\*\//g;
-      const matches = result.match(jsDocRegex) || [];
-      jsDocComments.push(...matches);
-    }
-    
-    // Step 2: Remove comments if configured
-    if (this.config.removeComments) {
-      // Remove single-line comments
-      result = result.replace(/\/\/.*$/gm, '');
-      // Remove multi-line comments (except JSDoc if preserveJSDoc is true)
-      if (!this.config.preserveJSDoc) {
-        result = result.replace(/\/\*[\s\S]*?\*\//g, '');
-      } else {
-        // Only remove non-JSDoc comments
-        result = result.replace(/\/\*(?!\*)[\s\S]*?\*\//g, '');
-      }
-    }
-    
-    // Step 3: Remove function implementations if configured
-    if (this.config.removeImplementations) {
-      // Match function and method bodies
-      result = result.replace(
-        /(\b(function|constructor|async function)\s+[\w$]*\s*\([^)]*\)\s*{)([\s\S]*?)(})/g,
-        (match, start, funcType, body, end) => {
-          // Keep function signature and opening brace, replace body with comment
-          return `${start} /* implementation removed */ ${end}`;
-        }
-      );
-      
-      // Match arrow function bodies
-      result = result.replace(
-        /(\([^)]*\)\s*=>\s*{)([\s\S]*?)(})/g,
-        (match, start, body, end) => {
-          return `${start} /* implementation removed */ ${end}`;
-        }
-      );
-      
-      // Match method declarations
-      result = result.replace(
-        /(^\s*[\w$]*\s*\([^)]*\)\s*{)([\s\S]*?)(})/gm,
-        (match, start, body, end) => {
-          return `${start} /* implementation removed */ ${end}`;
-        }
-      );
-      
-      // Match class methods
-      result = result.replace(
-        /(\b(public|private|protected|static|async)?\s+[\w$]+\s*\([^)]*\)\s*{)([\s\S]*?)(})/g,
-        (match, start, modifier, body, end) => {
-          return `${start} /* implementation removed */ ${end}`;
-        }
-      );
-    } else if (this.config.maxFunctionLines && this.config.maxFunctionLines > 0) {
-      // If not removing implementations completely, limit the number of lines
-      // Match function and method bodies
-      result = result.replace(
-        /(\b(function|constructor|async function)\s+[\w$]*\s*\([^)]*\)\s*{)([\s\S]*?)(})/g,
-        (match, start, funcType, body, end) => {
-          return this.limitFunctionBody(start, body, end);
-        }
-      );
-      
-      // Match arrow function bodies
-      result = result.replace(
-        /(\([^)]*\)\s*=>\s*{)([\s\S]*?)(})/g,
-        (match, start, body, end) => {
-          return this.limitFunctionBody(start, body, end);
-        }
-      );
-      
-      // Match method declarations
-      result = result.replace(
-        /(^\s*[\w$]*\s*\([^)]*\)\s*{)([\s\S]*?)(})/gm,
-        (match, start, body, end) => {
-          return this.limitFunctionBody(start, body, end);
-        }
-      );
-      
-      // Match class methods
-      result = result.replace(
-        /(\b(public|private|protected|static|async)?\s+[\w$]+\s*\([^)]*\)\s*{)([\s\S]*?)(})/g,
-        (match, start, modifier, body, end) => {
-          return this.limitFunctionBody(start, body, end);
-        }
-      );
-    }
-    
-    // Step 4: Remove blank lines if configured
-    if (this.config.removeBlankLines) {
-      result = result.replace(/^\s*[\r\n]/gm, '');
-    }
-    
-    // Step 5: Restore preserved JSDoc comments
-    if (this.config.preserveJSDoc && jsDocComments.length > 0) {
-      // This is a placeholder; we already preserved JSDoc comments in the regex steps
-    }
-    
-    return result;
-  }
-  
-  /**
-   * Limit a function body to a maximum number of lines
-   * @param start The function signature and opening brace
-   * @param body The function body
-   * @param end The closing brace
-   * @returns The limited function body
-   */
-  private limitFunctionBody(start: string, body: string, end: string): string {
-    const lines = body.split('\n');
-    if (lines.length > this.config.maxFunctionLines!) {
-      const limitedBody = lines.slice(0, this.config.maxFunctionLines!).join('\n');
-      return `${start}${limitedBody}\n  // ... (${lines.length - this.config.maxFunctionLines!} lines trimmed)\n${end}`;
-    }
-    return `${start}${body}${end}`;
-  }
-  
-  /**
-   * Trim a Markdown file to reduce token usage
-   * @param content The Markdown file contents
-   * @returns The trimmed file contents
-   */
-  private trimMarkdownFile(content: string): string {
-    // For markdown files, we generally want to keep most content
-    // but we can remove lengthy code blocks if needed
-    return content;
-  }
-  
-  /**
-   * Trim a JSON file to reduce token usage
-   * @param content The JSON file contents
-   * @returns The trimmed file contents
-   */
-  private trimJsonFile(content: string): string {
-    try {
-      // Parse the JSON
-      const json = JSON.parse(content);
-      
-      // For package.json, keep only essential information
-      if ('name' in json && 'version' in json && 'dependencies' in json) {
-        const essentialKeys = [
-          'name', 'version', 'description', 'author', 'license',
-          'main', 'types', 'exports', 'type'
-        ];
-        
-        const trimmedJson: any = {};
-        essentialKeys.forEach(key => {
-          if (key in json) {
-            trimmedJson[key] = json[key];
-          }
-        });
-        
-        // Add dependency information without versions
-        if ('dependencies' in json) {
-          trimmedJson.dependencies = Object.keys(json.dependencies).reduce((acc, dep) => {
-            acc[dep] = '*'; // Replace version with wildcard
-            return acc;
-          }, {} as Record<string, string>);
-        }
-        
-        // Return the trimmed JSON
-        return JSON.stringify(trimmedJson, null, 2);
-      }
-      
-      // For other JSON files, leave as is
-      return content;
-    } catch (error) {
-      // If there's an error parsing the JSON, return the original content
-      return content;
-    }
-  }
-  
-  /**
-   * Update the trimmer configuration
-   * @param config The new configuration to apply
-   */
-  public updateConfig(config: ITrimConfig): void {
-    this.config = {
-      ...this.config,
-      ...config
-    };
-  }
-
-  /**
-   * Trim a file based on its importance tier
-   * @param filePath The path to the file
-   * @param content The file's contents
-   * @param level The trimming level to apply ('none', 'light', 'aggressive')
-   * @returns The trimmed file contents
-   */
-  public trimFileWithLevel(
-    filePath: string,
-    content: string,
-    level: 'none' | 'light' | 'aggressive'
-  ): string {
-    // No trimming for essential files
-    if (level === 'none') {
-      return content;
-    }
-
-    // Create a temporary config based on level
-    const originalConfig = { ...this.config };
-
-    try {
-      if (level === 'light') {
-        // Light trimming: preserve signatures, remove only complex implementations
-        this.config = {
-          ...this.config,
-          removeImplementations: false,
-          preserveInterfaces: true,
-          preserveTypeDefs: true,
-          preserveJSDoc: true,
-          maxFunctionLines: 10,
-          removeComments: false,
-          removeBlankLines: true
-        };
-      } else if (level === 'aggressive') {
-        // Aggressive trimming: remove all implementations, keep only signatures
-        this.config = {
-          ...this.config,
-          removeImplementations: true,
-          preserveInterfaces: true,
-          preserveTypeDefs: true,
-          preserveJSDoc: true,
-          maxFunctionLines: 3,
-          removeComments: true,
-          removeBlankLines: true
-        };
-      }
-
-      // Process based on file type
-      let result = content;
-      if (filePath.endsWith('.ts') || filePath.endsWith('.tsx')) {
-        result = this.trimTypeScriptFile(content);
-      } else if (filePath.endsWith('.md')) {
-        result = this.trimMarkdownFile(content);
-      } else if (filePath.endsWith('.json')) {
-        result = this.trimJsonFile(content);
-      }
-
-      return result;
-    } finally {
-      // Restore original config
-      this.config = originalConfig;
-    }
-  }
-}

package/ts/context/enhanced-context.ts

@@ -1,332 +0,0 @@
-import * as plugins from '../plugins.js';
-import type { ContextMode, IContextResult, IFileInfo, TaskType, IFileMetadata } from './types.js';
-import { ContextTrimmer } from './context-trimmer.js';
-import { ConfigManager } from './config-manager.js';
-import { LazyFileLoader } from './lazy-file-loader.js';
-import { ContextCache } from './context-cache.js';
-import { ContextAnalyzer } from './context-analyzer.js';
-
-/**
- * Enhanced ProjectContext that supports context optimization strategies
- */
-export class EnhancedContext {
-  private projectDir: string;
-  private trimmer: ContextTrimmer;
-  private configManager: ConfigManager;
-  private lazyLoader: LazyFileLoader;
-  private cache: ContextCache;
-  private analyzer: ContextAnalyzer;
-  private contextMode: ContextMode = 'trimmed';
-  private tokenBudget: number = 190000; // Default for o4-mini
-  private contextResult: IContextResult = {
-    context: '',
-    tokenCount: 0,
-    includedFiles: [],
-    trimmedFiles: [],
-    excludedFiles: [],
-    tokenSavings: 0
-  };
-  
-  /**
-   * Create a new EnhancedContext
-   * @param projectDirArg The project directory
-   */
-  constructor(projectDirArg: string) {
-    this.projectDir = projectDirArg;
-    this.configManager = ConfigManager.getInstance();
-    this.trimmer = new ContextTrimmer(this.configManager.getTrimConfig());
-    this.lazyLoader = new LazyFileLoader(projectDirArg);
-    this.cache = new ContextCache(projectDirArg, this.configManager.getCacheConfig());
-    this.analyzer = new ContextAnalyzer(
-      projectDirArg,
-      this.configManager.getPrioritizationWeights(),
-      this.configManager.getTierConfig()
-    );
-  }
-  
-  /**
-   * Initialize the context builder
-   */
-  public async initialize(): Promise<void> {
-    await this.configManager.initialize(this.projectDir);
-    this.tokenBudget = this.configManager.getMaxTokens();
-    this.trimmer.updateConfig(this.configManager.getTrimConfig());
-    await this.cache.init();
-  }
-  
-  /**
-   * Set the context mode
-   * @param mode The context mode to use
-   */
-  public setContextMode(mode: ContextMode): void {
-    this.contextMode = mode;
-  }
-  
-  /**
-   * Set the token budget
-   * @param maxTokens The maximum tokens to use
-   */
-  public setTokenBudget(maxTokens: number): void {
-    this.tokenBudget = maxTokens;
-  }
-
-  /**
-   * Convert files to context with smart analysis and prioritization
-   * @param metadata - File metadata to analyze
-   * @param taskType - Task type for context-aware prioritization
-   * @param mode - Context mode to use
-   * @returns Context string
-   */
-  public async convertFilesToContextWithAnalysis(
-    metadata: IFileMetadata[],
-    taskType: TaskType,
-    mode: ContextMode = this.contextMode
-  ): Promise<string> {
-    // Reset context result
-    this.contextResult = {
-      context: '',
-      tokenCount: 0,
-      includedFiles: [],
-      trimmedFiles: [],
-      excludedFiles: [],
-      tokenSavings: 0
-    };
-
-    // Analyze files for smart prioritization
-    const analysis = await this.analyzer.analyze(metadata, taskType, []);
-
-    // Sort files by importance score (highest first)
-    const sortedAnalysis = [...analysis.files].sort(
-      (a, b) => b.importanceScore - a.importanceScore
-    );
-
-    // Filter out excluded tier
-    const relevantFiles = sortedAnalysis.filter(f => f.tier !== 'excluded');
-
-    let totalTokenCount = 0;
-    let totalOriginalTokens = 0;
-    const processedFiles: string[] = [];
-
-    // Load files with cache support
-    for (const fileAnalysis of relevantFiles) {
-      try {
-        // Check cache first
-        let contents: string;
-        let originalTokenCount: number;
-
-        const cached = await this.cache.get(fileAnalysis.path);
-        if (cached) {
-          contents = cached.contents;
-          originalTokenCount = cached.tokenCount;
-        } else {
-          // Load file
-          const fileData = await plugins.fsInstance.file(fileAnalysis.path).encoding('utf8').read() as string;
-          contents = fileData;
-          originalTokenCount = this.countTokens(contents);
-
-          // Cache it
-          await this.cache.set({
-            path: fileAnalysis.path,
-            contents,
-            tokenCount: originalTokenCount,
-            mtime: Date.now(),
-            cachedAt: Date.now()
-          });
-        }
-
-        totalOriginalTokens += originalTokenCount;
-
-        // Apply tier-based trimming
-        let processedContent = contents;
-        let trimLevel: 'none' | 'light' | 'aggressive' = 'light';
-
-        if (fileAnalysis.tier === 'essential') {
-          trimLevel = 'none';
-        } else if (fileAnalysis.tier === 'important') {
-          trimLevel = 'light';
-        } else if (fileAnalysis.tier === 'optional') {
-          trimLevel = 'aggressive';
-        }
-
-        // Apply trimming based on mode and tier
-        if (mode !== 'full' && trimLevel !== 'none') {
-          const relativePath = plugins.path.relative(this.projectDir, fileAnalysis.path);
-          processedContent = this.trimmer.trimFileWithLevel(
-            relativePath,
-            contents,
-            trimLevel
-          );
-        }
-
-        // Calculate token count
-        const processedTokenCount = this.countTokens(processedContent);
-
-        // Check token budget
-        if (totalTokenCount + processedTokenCount > this.tokenBudget) {
-          // We don't have budget for this file
-          const relativePath = plugins.path.relative(this.projectDir, fileAnalysis.path);
-          this.contextResult.excludedFiles.push({
-            path: fileAnalysis.path,
-            contents,
-            relativePath,
-            tokenCount: originalTokenCount,
-            importanceScore: fileAnalysis.importanceScore
-          });
-          continue;
-        }
-
-        // Format the file for context
-        const relativePath = plugins.path.relative(this.projectDir, fileAnalysis.path);
-        const formattedContent = `
-====== START OF FILE ${relativePath} ======
-
-${processedContent}
-
-====== END OF FILE ${relativePath} ======
-        `;
-
-        processedFiles.push(formattedContent);
-        totalTokenCount += processedTokenCount;
-
-        // Track file in appropriate list
-        const fileInfo: IFileInfo = {
-          path: fileAnalysis.path,
-          contents: processedContent,
-          relativePath,
-          tokenCount: processedTokenCount,
-          importanceScore: fileAnalysis.importanceScore
-        };
-
-        if (trimLevel === 'none' || processedContent === contents) {
-          this.contextResult.includedFiles.push(fileInfo);
-        } else {
-          this.contextResult.trimmedFiles.push(fileInfo);
-          this.contextResult.tokenSavings += (originalTokenCount - processedTokenCount);
-        }
-      } catch (error) {
-        console.warn(`Failed to process file ${fileAnalysis.path}:`, error.message);
-      }
-    }
-
-    // Join all processed files
-    const context = processedFiles.join('\n');
-
-    // Update context result
-    this.contextResult.context = context;
-    this.contextResult.tokenCount = totalTokenCount;
-
-    return context;
-  }
-
-  /**
-   * Build context for the project using smart analysis
-   * @param taskType Task type for context-aware prioritization (defaults to 'description')
-   */
-  public async buildContext(taskType?: TaskType): Promise<IContextResult> {
-    // Initialize if needed
-    if (this.tokenBudget === 0) {
-      await this.initialize();
-    }
-
-    // Smart context building always requires a task type for optimal prioritization
-    // Default to 'description' if not provided
-    const effectiveTaskType = taskType || 'description';
-
-    // Get task-specific configuration
-    const taskConfig = this.configManager.getTaskConfig(effectiveTaskType);
-    if (taskConfig.mode) {
-      this.setContextMode(taskConfig.mode);
-    }
-
-    // Build globs for scanning
-    const includeGlobs = taskConfig?.includePaths?.map(p => `${p}/**/*.ts`) || [
-      'ts/**/*.ts',
-      'ts*/**/*.ts'
-    ];
-
-    // Add config files
-    const configGlobs = [
-      'package.json',
-      'readme.md',
-      'readme.hints.md',
-      'npmextra.json'
-    ];
-
-    // Scan files for metadata (fast, doesn't load contents)
-    const metadata = await this.lazyLoader.scanFiles([...configGlobs, ...includeGlobs]);
-
-    // Use smart analyzer to build context with intelligent prioritization
-    await this.convertFilesToContextWithAnalysis(metadata, effectiveTaskType, this.contextMode);
-
-    return this.contextResult;
-  }
-  
-  /**
-   * Update the context with git diff information for commit tasks
-   * @param gitDiff The git diff to include
-   */
-  public updateWithGitDiff(gitDiff: string): IContextResult {
-    // If we don't have a context yet, return empty result
-    if (!this.contextResult.context) {
-      return this.contextResult;
-    }
-    
-    // Add git diff to context
-    const diffSection = `
-====== GIT DIFF ======
-
-${gitDiff}
-
-====== END GIT DIFF ======
-    `;
-    
-    const diffTokenCount = this.countTokens(diffSection);
-    
-    // Update context and token count
-    this.contextResult.context += diffSection;
-    this.contextResult.tokenCount += diffTokenCount;
-    
-    return this.contextResult;
-  }
-  
-  /**
-   * Count tokens in a string
-   * @param text The text to count tokens for
-   * @param model The model to use for token counting
-   */
-  public countTokens(text: string, model: string = 'gpt-3.5-turbo'): number {
-    try {
-      // Use the gpt-tokenizer library to count tokens
-      const tokens = plugins.gptTokenizer.encode(text);
-      return tokens.length;
-    } catch (error) {
-      console.error('Error counting tokens:', error);
-      // Provide a rough estimate if tokenization fails
-      return Math.ceil(text.length / 4);
-    }
-  }
-  
-  /**
-   * Get the context result
-   */
-  public getContextResult(): IContextResult {
-    return this.contextResult;
-  }
-  
-  /**
-   * Get the token count for the current context
-   */
-  public getTokenCount(): number {
-    return this.contextResult.tokenCount;
-  }
-  
-  /**
-   * Get both the context string and its token count
-   */
-  public getContextWithTokenCount(): { context: string; tokenCount: number } {
-    return {
-      context: this.contextResult.context,
-      tokenCount: this.contextResult.tokenCount
-    };
-  }
-}

package/ts/context/index.ts

@@ -1,70 +0,0 @@
-import { EnhancedContext } from './enhanced-context.js';
-import { TaskContextFactory } from './task-context-factory.js';
-import { ConfigManager } from './config-manager.js';
-import { ContextTrimmer } from './context-trimmer.js';
-import { LazyFileLoader } from './lazy-file-loader.js';
-import { ContextCache } from './context-cache.js';
-import { ContextAnalyzer } from './context-analyzer.js';
-import { DiffProcessor } from './diff-processor.js';
-import type {
-  ContextMode,
-  IContextConfig,
-  IContextResult,
-  IFileInfo,
-  ITrimConfig,
-  ITaskConfig,
-  TaskType,
-  ICacheConfig,
-  IAnalyzerConfig,
-  IPrioritizationWeights,
-  ITierConfig,
-  ITierSettings,
-  IFileMetadata,
-  ICacheEntry,
-  IFileDependencies,
-  IFileAnalysis,
-  IAnalysisResult,
-  IIterativeConfig,
-  IIterativeContextResult,
-  IDiffFileInfo,
-  IProcessedDiff,
-  IDiffProcessorOptions
-} from './types.js';
-
-export {
-  // Classes
-  EnhancedContext,
-  TaskContextFactory,
-  ConfigManager,
-  ContextTrimmer,
-  LazyFileLoader,
-  ContextCache,
-  ContextAnalyzer,
-  DiffProcessor,
-};
-
-// Types
-export type {
-  ContextMode,
-  IContextConfig,
-  IContextResult,
-  IFileInfo,
-  ITrimConfig,
-  ITaskConfig,
-  TaskType,
-  ICacheConfig,
-  IAnalyzerConfig,
-  IPrioritizationWeights,
-  ITierConfig,
-  ITierSettings,
-  IFileMetadata,
-  ICacheEntry,
-  IFileDependencies,
-  IFileAnalysis,
-  IAnalysisResult,
-  IIterativeConfig,
-  IIterativeContextResult,
-  IDiffFileInfo,
-  IProcessedDiff,
-  IDiffProcessorOptions
-};