@git.zone/tsdoc/ts/context/task-context-factory.ts

A comprehensive TypeScript documentation tool that leverages AI to generate and enhance project documentation, including dynamic README creation, API docs via TypeDoc, and smart commit message generation.

import * as plugins from '../plugins.js';
import { EnhancedContext } from './enhanced-context.js';
import { ConfigManager } from './config-manager.js';
import type { IContextResult, TaskType } from './types.js';

/**
 * Factory class for creating task-specific context
 */
export class TaskContextFactory {
  private projectDir: string;
  private configManager: ConfigManager;
  
  /**
   * Create a new TaskContextFactory
   * @param projectDirArg The project directory
   */
  constructor(projectDirArg: string) {
    this.projectDir = projectDirArg;
    this.configManager = ConfigManager.getInstance();
  }
  
  /**
   * Initialize the factory
   */
  public async initialize(): Promise<void> {
    await this.configManager.initialize(this.projectDir);
  }
  
  /**
   * Create context for README generation
   */
  public async createContextForReadme(): Promise<IContextResult> {
    const contextBuilder = new EnhancedContext(this.projectDir);
    await contextBuilder.initialize();
    
    // Get README-specific configuration
    const taskConfig = this.configManager.getTaskConfig('readme');
    if (taskConfig.mode) {
      contextBuilder.setContextMode(taskConfig.mode);
    }
    
    // Build the context for README task
    return await contextBuilder.buildContext('readme');
  }
  
  /**
   * Create context for description generation
   */
  public async createContextForDescription(): Promise<IContextResult> {
    const contextBuilder = new EnhancedContext(this.projectDir);
    await contextBuilder.initialize();
    
    // Get description-specific configuration
    const taskConfig = this.configManager.getTaskConfig('description');
    if (taskConfig.mode) {
      contextBuilder.setContextMode(taskConfig.mode);
    }
    
    // Build the context for description task
    return await contextBuilder.buildContext('description');
  }
  
  /**
   * Create context for commit message generation
   * @param gitDiff Optional git diff to include
   */
  public async createContextForCommit(gitDiff?: string): Promise<IContextResult> {
    const contextBuilder = new EnhancedContext(this.projectDir);
    await contextBuilder.initialize();
    
    // Get commit-specific configuration
    const taskConfig = this.configManager.getTaskConfig('commit');
    if (taskConfig.mode) {
      contextBuilder.setContextMode(taskConfig.mode);
    }
    
    // Build the context for commit task
    const contextResult = await contextBuilder.buildContext('commit');
    
    // If git diff is provided, add it to the context
    if (gitDiff) {
      contextBuilder.updateWithGitDiff(gitDiff);
    }
    
    return contextBuilder.getContextResult();
  }
  
  /**
   * Create context for any task type
   * @param taskType The task type to create context for
   * @param additionalContent Optional additional content to include
   */
  public async createContextForTask(
    taskType: TaskType,
    additionalContent?: string
  ): Promise<IContextResult> {
    switch (taskType) {
      case 'readme':
        return this.createContextForReadme();
      case 'description':
        return this.createContextForDescription();
      case 'commit':
        return this.createContextForCommit(additionalContent);
      default:
        // Generic context for unknown task types
        const contextBuilder = new EnhancedContext(this.projectDir);
        await contextBuilder.initialize();
        return await contextBuilder.buildContext();
    }
  }
  
  /**
   * Get token stats for all task types
   */
  public async getTokenStats(): Promise<Record<TaskType, {
    tokenCount: number;
    savings: number;
    includedFiles: number;
    trimmedFiles: number;
    excludedFiles: number;
  }>> {
    const taskTypes: TaskType[] = ['readme', 'description', 'commit'];
    const stats: Record<TaskType, any> = {} as any;
    
    for (const taskType of taskTypes) {
      const result = await this.createContextForTask(taskType);
      stats[taskType] = {
        tokenCount: result.tokenCount,
        savings: result.tokenSavings,
        includedFiles: result.includedFiles.length,
        trimmedFiles: result.trimmedFiles.length,
        excludedFiles: result.excludedFiles.length
      };
    }
    
    return stats;
  }
}