@git.zone/tsdoc 1.4.5 → 1.5.0

package/ts/context/config-manager.ts

@@ -0,0 +1,209 @@
+import * as plugins from '../plugins.js';
+import type { IContextConfig, ITrimConfig, ITaskConfig, TaskType, ContextMode } from './types.js';
+
+/**
+ * Manages configuration for context building
+ */
+export class ConfigManager {
+  private static instance: ConfigManager;
+  private config: IContextConfig;
+  private projectDir: string = '';
+  
+  /**
+   * Get the singleton instance of ConfigManager
+   */
+  public static getInstance(): ConfigManager {
+    if (!ConfigManager.instance) {
+      ConfigManager.instance = new ConfigManager();
+    }
+    return ConfigManager.instance;
+  }
+  
+  /**
+   * Private constructor for singleton pattern
+   */
+  private constructor() {
+    this.config = this.getDefaultConfig();
+  }
+  
+  /**
+   * Initialize the config manager with a project directory
+   * @param projectDir The project directory
+   */
+  public async initialize(projectDir: string): Promise<void> {
+    this.projectDir = projectDir;
+    await this.loadConfig();
+  }
+  
+  /**
+   * Get the default configuration
+   */
+  private getDefaultConfig(): IContextConfig {
+    return {
+      maxTokens: 190000, // Default for o4-mini with some buffer
+      defaultMode: 'trimmed',
+      taskSpecificSettings: {
+        readme: {
+          mode: 'trimmed',
+          includePaths: ['ts/', 'src/'],
+          excludePaths: ['test/', 'node_modules/']
+        },
+        commit: {
+          mode: 'trimmed',
+          focusOnChangedFiles: true
+        },
+        description: {
+          mode: 'trimmed',
+          includePackageInfo: true
+        }
+      },
+      trimming: {
+        removeImplementations: true,
+        preserveInterfaces: true,
+        preserveTypeDefs: true,
+        preserveJSDoc: true,
+        maxFunctionLines: 5,
+        removeComments: true,
+        removeBlankLines: true
+      }
+    };
+  }
+  
+  /**
+   * Load configuration from npmextra.json
+   */
+  private async loadConfig(): Promise<void> {
+    try {
+      if (!this.projectDir) {
+        return;
+      }
+      
+      // Create KeyValueStore for this project
+      // We'll just use smartfile directly instead of KeyValueStore
+      
+      // Read the npmextra.json file
+      const npmextraJsonFile = await plugins.smartfile.SmartFile.fromFilePath(
+        plugins.path.join(this.projectDir, 'npmextra.json')
+      );
+      const npmextraContent = JSON.parse(npmextraJsonFile.contents.toString());
+      
+      // Check for tsdoc context configuration
+      if (npmextraContent?.tsdoc?.context) {
+        // Merge with default config
+        this.config = this.mergeConfigs(this.config, npmextraContent.tsdoc.context);
+      }
+    } catch (error) {
+      console.error('Error loading context configuration:', error);
+    }
+  }
+  
+  /**
+   * Merge configurations, with userConfig taking precedence
+   * @param defaultConfig The default configuration
+   * @param userConfig The user configuration
+   */
+  private mergeConfigs(defaultConfig: IContextConfig, userConfig: Partial<IContextConfig>): IContextConfig {
+    const result: IContextConfig = { ...defaultConfig };
+    
+    // Merge top-level properties
+    if (userConfig.maxTokens !== undefined) result.maxTokens = userConfig.maxTokens;
+    if (userConfig.defaultMode !== undefined) result.defaultMode = userConfig.defaultMode;
+    
+    // Merge task-specific settings
+    if (userConfig.taskSpecificSettings) {
+      result.taskSpecificSettings = result.taskSpecificSettings || {};
+      
+      // For each task type, merge settings
+      (['readme', 'commit', 'description'] as TaskType[]).forEach(taskType => {
+        if (userConfig.taskSpecificSettings?.[taskType]) {
+          result.taskSpecificSettings![taskType] = {
+            ...result.taskSpecificSettings![taskType],
+            ...userConfig.taskSpecificSettings[taskType]
+          };
+        }
+      });
+    }
+    
+    // Merge trimming configuration
+    if (userConfig.trimming) {
+      result.trimming = {
+        ...result.trimming,
+        ...userConfig.trimming
+      };
+    }
+    
+    return result;
+  }
+  
+  /**
+   * Get the complete configuration
+   */
+  public getConfig(): IContextConfig {
+    return this.config;
+  }
+  
+  /**
+   * Get the trimming configuration
+   */
+  public getTrimConfig(): ITrimConfig {
+    return this.config.trimming || {};
+  }
+  
+  /**
+   * Get configuration for a specific task
+   * @param taskType The type of task
+   */
+  public getTaskConfig(taskType: TaskType): ITaskConfig {
+    // Get task-specific config or empty object
+    const taskConfig = this.config.taskSpecificSettings?.[taskType] || {};
+    
+    // If mode is not specified, use default mode
+    if (!taskConfig.mode) {
+      taskConfig.mode = this.config.defaultMode;
+    }
+    
+    return taskConfig;
+  }
+  
+  /**
+   * Get the maximum tokens allowed for context
+   */
+  public getMaxTokens(): number {
+    return this.config.maxTokens || 190000;
+  }
+  
+  /**
+   * Update the configuration
+   * @param config The new configuration
+   */
+  public async updateConfig(config: Partial<IContextConfig>): Promise<void> {
+    // Merge with existing config
+    this.config = this.mergeConfigs(this.config, config);
+    
+    try {
+      if (!this.projectDir) {
+        return;
+      }
+      
+      // Read the existing npmextra.json file
+      const npmextraJsonPath = plugins.path.join(this.projectDir, 'npmextra.json');
+      let npmextraContent = {};
+      
+      if (await plugins.smartfile.fs.fileExists(npmextraJsonPath)) {
+        const npmextraJsonFile = await plugins.smartfile.SmartFile.fromFilePath(npmextraJsonPath);
+        npmextraContent = JSON.parse(npmextraJsonFile.contents.toString()) || {};
+      }
+      
+      // Update the tsdoc context configuration
+      const typedContent = npmextraContent as any;
+      if (!typedContent.tsdoc) typedContent.tsdoc = {};
+      typedContent.tsdoc.context = this.config;
+      
+      // Write back to npmextra.json
+      const updatedContent = JSON.stringify(npmextraContent, null, 2);
+      await plugins.smartfile.memory.toFs(updatedContent, npmextraJsonPath);
+    } catch (error) {
+      console.error('Error updating context configuration:', error);
+    }
+  }
+}

package/ts/context/context-trimmer.ts

@@ -0,0 +1,246 @@
+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
+    };
+  }
+}