@git.zone/tsdoc 1.11.1 → 1.11.3

package/ts/context/lazy-file-loader.ts

@@ -1,207 +0,0 @@
-import * as plugins from '../plugins.js';
-import * as fs from 'fs';
-import type { IFileMetadata, IFileInfo } from './types.js';
-
-/**
- * LazyFileLoader handles efficient file loading by:
- * - Scanning files for metadata without loading contents
- * - Providing fast file size and token estimates
- * - Loading contents only when requested
- * - Parallel loading of selected files
- */
-export class LazyFileLoader {
-  private projectRoot: string;
-  private metadataCache: Map<string, IFileMetadata> = new Map();
-
-  /**
-   * Creates a new LazyFileLoader
-   * @param projectRoot - Root directory of the project
-   */
-  constructor(projectRoot: string) {
-    this.projectRoot = projectRoot;
-  }
-
-  /**
-   * Scans files in given globs and creates metadata without loading contents
-   * @param globs - File patterns to scan (e.g., ['ts/**\/*.ts', 'test/**\/*.ts'])
-   * @returns Array of file metadata
-   */
-  public async scanFiles(globs: string[]): Promise<IFileMetadata[]> {
-    const metadata: IFileMetadata[] = [];
-
-    for (const globPattern of globs) {
-      try {
-        const virtualDir = await plugins.smartfileFactory.virtualDirectoryFromPath(this.projectRoot);
-        // Filter files based on glob pattern using simple pattern matching
-        const smartFiles = virtualDir.filter(file => {
-          // Simple glob matching
-          const relativePath = file.relative;
-          if (globPattern.includes('**')) {
-            // Handle ** patterns - match any path
-            const pattern = globPattern.replace(/\*\*/g, '.*').replace(/\*/g, '[^/]*');
-            return new RegExp(`^${pattern}$`).test(relativePath);
-          } else if (globPattern.includes('*')) {
-            // Handle single * patterns
-            const pattern = globPattern.replace(/\*/g, '[^/]*');
-            return new RegExp(`^${pattern}$`).test(relativePath);
-          } else {
-            // Exact match
-            return relativePath === globPattern;
-          }
-        }).listFiles();
-
-        for (const smartFile of smartFiles) {
-          try {
-            const meta = await this.getMetadata(smartFile.absolutePath);
-            metadata.push(meta);
-          } catch (error) {
-            // Skip files that can't be read
-            console.warn(`Failed to get metadata for ${smartFile.absolutePath}:`, error.message);
-          }
-        }
-      } catch (error) {
-        // Skip patterns that don't match any files
-        console.warn(`No files found for pattern ${globPattern}`);
-      }
-    }
-
-    return metadata;
-  }
-
-  /**
-   * Gets metadata for a single file without loading contents
-   * @param filePath - Absolute path to the file
-   * @returns File metadata
-   */
-  public async getMetadata(filePath: string): Promise<IFileMetadata> {
-    // Check cache first
-    if (this.metadataCache.has(filePath)) {
-      const cached = this.metadataCache.get(filePath)!;
-      const currentStats = await fs.promises.stat(filePath);
-
-      // Return cached if file hasn't changed
-      if (cached.mtime === Math.floor(currentStats.mtimeMs)) {
-        return cached;
-      }
-    }
-
-    // Get file stats
-    const stats = await fs.promises.stat(filePath);
-    const relativePath = plugins.path.relative(this.projectRoot, filePath);
-
-    // Estimate tokens: rough estimate of ~4 characters per token
-    // This is faster than reading and tokenizing the entire file
-    const estimatedTokens = Math.ceil(stats.size / 4);
-
-    const metadata: IFileMetadata = {
-      path: filePath,
-      relativePath,
-      size: stats.size,
-      mtime: Math.floor(stats.mtimeMs),
-      estimatedTokens,
-    };
-
-    // Cache the metadata
-    this.metadataCache.set(filePath, metadata);
-
-    return metadata;
-  }
-
-  /**
-   * Loads file contents for selected files in parallel
-   * @param metadata - Array of file metadata to load
-   * @param tokenizer - Function to calculate accurate token count
-   * @returns Array of complete file info with contents
-   */
-  public async loadFiles(
-    metadata: IFileMetadata[],
-    tokenizer: (content: string) => number
-  ): Promise<IFileInfo[]> {
-    // Load files in parallel
-    const loadPromises = metadata.map(async (meta) => {
-      try {
-        const contents = await plugins.fsInstance.file(meta.path).encoding('utf8').read() as string;
-        const tokenCount = tokenizer(contents);
-
-        const fileInfo: IFileInfo = {
-          path: meta.path,
-          relativePath: meta.relativePath,
-          contents,
-          tokenCount,
-          importanceScore: meta.importanceScore,
-        };
-
-        return fileInfo;
-      } catch (error) {
-        console.warn(`Failed to load file ${meta.path}:`, error.message);
-        return null;
-      }
-    });
-
-    // Wait for all loads to complete and filter out failures
-    const results = await Promise.all(loadPromises);
-    return results.filter((r): r is IFileInfo => r !== null);
-  }
-
-  /**
-   * Loads a single file with contents
-   * @param filePath - Absolute path to the file
-   * @param tokenizer - Function to calculate accurate token count
-   * @returns Complete file info with contents
-   */
-  public async loadFile(
-    filePath: string,
-    tokenizer: (content: string) => number
-  ): Promise<IFileInfo> {
-    const meta = await this.getMetadata(filePath);
-    const contents = await plugins.fsInstance.file(filePath).encoding('utf8').read() as string;
-    const tokenCount = tokenizer(contents);
-    const relativePath = plugins.path.relative(this.projectRoot, filePath);
-
-    return {
-      path: filePath,
-      relativePath,
-      contents,
-      tokenCount,
-      importanceScore: meta.importanceScore,
-    };
-  }
-
-  /**
-   * Updates importance scores for metadata entries
-   * @param scores - Map of file paths to importance scores
-   */
-  public updateImportanceScores(scores: Map<string, number>): void {
-    for (const [path, score] of scores) {
-      const meta = this.metadataCache.get(path);
-      if (meta) {
-        meta.importanceScore = score;
-      }
-    }
-  }
-
-  /**
-   * Clears the metadata cache
-   */
-  public clearCache(): void {
-    this.metadataCache.clear();
-  }
-
-  /**
-   * Gets total estimated tokens for all cached metadata
-   */
-  public getTotalEstimatedTokens(): number {
-    let total = 0;
-    for (const meta of this.metadataCache.values()) {
-      total += meta.estimatedTokens;
-    }
-    return total;
-  }
-
-  /**
-   * Gets cached metadata entries
-   */
-  public getCachedMetadata(): IFileMetadata[] {
-    return Array.from(this.metadataCache.values());
-  }
-}

package/ts/context/task-context-factory.ts

@@ -1,120 +0,0 @@
-import * as plugins from '../plugins.js';
-import { IterativeContextBuilder } from './iterative-context-builder.js';
-import { ConfigManager } from './config-manager.js';
-import type { IIterativeContextResult, TaskType } from './types.js';
-
-/**
- * Factory class for creating task-specific context using iterative context building
- */
-export class TaskContextFactory {
-  private projectDir: string;
-  private configManager: ConfigManager;
-  private openaiInstance?: any; // OpenAI provider instance
-
-  /**
-   * Create a new TaskContextFactory
-   * @param projectDirArg The project directory
-   * @param openaiInstance Optional pre-configured OpenAI provider instance
-   */
-  constructor(projectDirArg: string, openaiInstance?: any) {
-    this.projectDir = projectDirArg;
-    this.configManager = ConfigManager.getInstance();
-    this.openaiInstance = openaiInstance;
-  }
-
-  /**
-   * Initialize the factory
-   */
-  public async initialize(): Promise<void> {
-    await this.configManager.initialize(this.projectDir);
-  }
-
-  /**
-   * Create context for README generation
-   */
-  public async createContextForReadme(): Promise<IIterativeContextResult> {
-    const iterativeBuilder = new IterativeContextBuilder(
-      this.projectDir,
-      this.configManager.getIterativeConfig(),
-      this.openaiInstance
-    );
-    await iterativeBuilder.initialize();
-    return await iterativeBuilder.buildContextIteratively('readme');
-  }
-
-  /**
-   * Create context for description generation
-   */
-  public async createContextForDescription(): Promise<IIterativeContextResult> {
-    const iterativeBuilder = new IterativeContextBuilder(
-      this.projectDir,
-      this.configManager.getIterativeConfig(),
-      this.openaiInstance
-    );
-    await iterativeBuilder.initialize();
-    return await iterativeBuilder.buildContextIteratively('description');
-  }
-
-  /**
-   * Create context for commit message generation
-   * @param gitDiff Optional git diff to include in the context
-   */
-  public async createContextForCommit(gitDiff?: string): Promise<IIterativeContextResult> {
-    const iterativeBuilder = new IterativeContextBuilder(
-      this.projectDir,
-      this.configManager.getIterativeConfig(),
-      this.openaiInstance
-    );
-    await iterativeBuilder.initialize();
-    return await iterativeBuilder.buildContextIteratively('commit', gitDiff);
-  }
-
-  /**
-   * Create context for any task type
-   * @param taskType The task type to create context for
-   * @param additionalContent Optional additional content (currently not used)
-   */
-  public async createContextForTask(
-    taskType: TaskType,
-    additionalContent?: string
-  ): Promise<IIterativeContextResult> {
-    switch (taskType) {
-      case 'readme':
-        return this.createContextForReadme();
-      case 'description':
-        return this.createContextForDescription();
-      case 'commit':
-        return this.createContextForCommit(additionalContent);
-      default:
-        // Default to readme for unknown task types
-        return this.createContextForReadme();
-    }
-  }
-
-  /**
-   * 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;
-  }
-}

package/ts/context/types.ts

@@ -1,324 +0,0 @@
-/**
- * Context processing mode to control how context is built
- */
-export type ContextMode = 'full' | 'trimmed' | 'summarized';
-
-/**
- * Configuration for context trimming
- */
-export interface ITrimConfig {
-  /** Whether to remove function implementations */
-  removeImplementations?: boolean;
-  /** Whether to preserve interface definitions */
-  preserveInterfaces?: boolean;
-  /** Whether to preserve type definitions */
-  preserveTypeDefs?: boolean;
-  /** Whether to preserve JSDoc comments */
-  preserveJSDoc?: boolean;
-  /** Maximum lines to keep for function bodies (if not removing completely) */
-  maxFunctionLines?: number;
-  /** Whether to remove normal comments (non-JSDoc) */
-  removeComments?: boolean;
-  /** Whether to remove blank lines */
-  removeBlankLines?: boolean;
-}
-
-/**
- * Task types that require different context optimization
- */
-export type TaskType = 'readme' | 'commit' | 'description';
-
-/**
- * Configuration for different tasks
- */
-export interface ITaskConfig {
-  /** The context mode to use for this task */
-  mode?: ContextMode;
-  /** File paths to include for this task */
-  includePaths?: string[];
-  /** File paths to exclude for this task */
-  excludePaths?: string[];
-  /** For commit tasks, whether to focus on changed files */
-  focusOnChangedFiles?: boolean;
-  /** For description tasks, whether to include package info */
-  includePackageInfo?: boolean;
-}
-
-/**
- * Complete context configuration
- */
-export interface IContextConfig {
-  /** Maximum tokens to use for context */
-  maxTokens?: number;
-  /** Default context mode */
-  defaultMode?: ContextMode;
-  /** Task-specific settings */
-  taskSpecificSettings?: {
-    [key in TaskType]?: ITaskConfig;
-  };
-  /** Trimming configuration */
-  trimming?: ITrimConfig;
-  /** Cache configuration */
-  cache?: ICacheConfig;
-  /** Analyzer configuration */
-  analyzer?: IAnalyzerConfig;
-  /** Prioritization weights */
-  prioritization?: IPrioritizationWeights;
-  /** Tier configuration for adaptive trimming */
-  tiers?: ITierConfig;
-  /** Iterative context building configuration */
-  iterative?: IIterativeConfig;
-}
-
-/**
- * Cache configuration
- */
-export interface ICacheConfig {
-  /** Whether caching is enabled */
-  enabled?: boolean;
-  /** Time-to-live in seconds */
-  ttl?: number;
-  /** Maximum cache size in MB */
-  maxSize?: number;
-  /** Cache directory path */
-  directory?: string;
-}
-
-/**
- * Analyzer configuration
- * Note: Smart analysis is always enabled; this config only controls advanced options
- */
-export interface IAnalyzerConfig {
-  /** Whether to use AI refinement for selection (advanced, disabled by default) */
-  useAIRefinement?: boolean;
-  /** AI model to use for refinement */
-  aiModel?: string;
-}
-
-/**
- * Weights for file prioritization
- */
-export interface IPrioritizationWeights {
-  /** Weight for dependency centrality */
-  dependencyWeight?: number;
-  /** Weight for task relevance */
-  relevanceWeight?: number;
-  /** Weight for token efficiency */
-  efficiencyWeight?: number;
-  /** Weight for file recency */
-  recencyWeight?: number;
-}
-
-/**
- * Tier configuration for adaptive trimming
- */
-export interface ITierConfig {
-  essential?: ITierSettings;
-  important?: ITierSettings;
-  optional?: ITierSettings;
-}
-
-/**
- * Settings for a single tier
- */
-export interface ITierSettings {
-  /** Minimum score to qualify for this tier */
-  minScore: number;
-  /** Trimming level to apply */
-  trimLevel: 'none' | 'light' | 'aggressive';
-}
-
-/**
- * Basic file information interface
- */
-export interface IFileInfo {
-  /** The file path */
-  path: string;
-  /** The file contents */
-  contents: string;
-  /** The file's relative path from the project root */
-  relativePath: string;
-  /** The estimated token count of the file */
-  tokenCount?: number;
-  /** The file's importance score (higher is more important) */
-  importanceScore?: number;
-}
-
-/**
- * Result of context building
- */
-export interface IContextResult {
-  /** The generated context string */
-  context: string;
-  /** The total token count of the context */
-  tokenCount: number;
-  /** Files included in the context */
-  includedFiles: IFileInfo[];
-  /** Files that were trimmed */
-  trimmedFiles: IFileInfo[];
-  /** Files that were excluded */
-  excludedFiles: IFileInfo[];
-  /** Token savings from trimming */
-  tokenSavings: number;
-}
-
-/**
- * File metadata without contents (for lazy loading)
- */
-export interface IFileMetadata {
-  /** The file path */
-  path: string;
-  /** The file's relative path from the project root */
-  relativePath: string;
-  /** File size in bytes */
-  size: number;
-  /** Last modified time (Unix timestamp) */
-  mtime: number;
-  /** Estimated token count (without loading full contents) */
-  estimatedTokens: number;
-  /** The file's importance score */
-  importanceScore?: number;
-}
-
-/**
- * Cache entry for a file
- */
-export interface ICacheEntry {
-  /** File path */
-  path: string;
-  /** File contents */
-  contents: string;
-  /** Token count */
-  tokenCount: number;
-  /** Last modified time when cached */
-  mtime: number;
-  /** When this cache entry was created */
-  cachedAt: number;
-}
-
-/**
- * Dependency information for a file
- */
-export interface IFileDependencies {
-  /** File path */
-  path: string;
-  /** Files this file imports */
-  imports: string[];
-  /** Files that import this file */
-  importedBy: string[];
-  /** Centrality score (0-1) - how central this file is in the dependency graph */
-  centrality: number;
-}
-
-/**
- * Analysis result for a file
- */
-export interface IFileAnalysis {
-  /** File path */
-  path: string;
-  /** Task relevance score (0-1) */
-  relevanceScore: number;
-  /** Dependency centrality score (0-1) */
-  centralityScore: number;
-  /** Token efficiency score (0-1) */
-  efficiencyScore: number;
-  /** Recency score (0-1) */
-  recencyScore: number;
-  /** Combined importance score (0-1) */
-  importanceScore: number;
-  /** Assigned tier */
-  tier: 'essential' | 'important' | 'optional' | 'excluded';
-  /** Reason for the score */
-  reason?: string;
-}
-
-/**
- * Result of context analysis
- */
-export interface IAnalysisResult {
-  /** Task type being analyzed */
-  taskType: TaskType;
-  /** Analyzed files with scores */
-  files: IFileAnalysis[];
-  /** Dependency graph */
-  dependencyGraph: Map<string, IFileDependencies>;
-  /** Total files analyzed */
-  totalFiles: number;
-  /** Analysis duration in ms */
-  analysisDuration: number;
-}
-
-/**
- * Configuration for iterative context building
- */
-export interface IIterativeConfig {
-  /** Maximum number of iterations allowed */
-  maxIterations?: number;
-  /** Maximum files to request in first iteration */
-  firstPassFileLimit?: number;
-  /** Maximum files to request in subsequent iterations */
-  subsequentPassFileLimit?: number;
-  /** Temperature for AI decision making (0-1) */
-  temperature?: number;
-  /** Model to use for iterative decisions */
-  model?: string;
-}
-
-/**
- * AI decision for file selection
- */
-export interface IFileSelectionDecision {
-  /** AI's reasoning for file selection */
-  reasoning: string;
-  /** File paths to load */
-  filesToLoad: string[];
-  /** Estimated tokens needed */
-  estimatedTokensNeeded?: number;
-}
-
-/**
- * AI decision for context sufficiency
- */
-export interface IContextSufficiencyDecision {
-  /** Whether context is sufficient */
-  sufficient: boolean;
-  /** AI's reasoning */
-  reasoning: string;
-  /** Additional files needed (if not sufficient) */
-  additionalFilesNeeded?: string[];
-}
-
-/**
- * State for a single iteration
- */
-export interface IIterationState {
-  /** Iteration number (1-based) */
-  iteration: number;
-  /** Files loaded in this iteration */
-  filesLoaded: IFileInfo[];
-  /** Tokens used in this iteration */
-  tokensUsed: number;
-  /** Total tokens used so far */
-  totalTokensUsed: number;
-  /** AI decision made in this iteration */
-  decision: IFileSelectionDecision | IContextSufficiencyDecision;
-  /** Duration of this iteration in ms */
-  duration: number;
-}
-
-/**
- * Result of iterative context building
- */
-export interface IIterativeContextResult extends IContextResult {
-  /** Number of iterations performed */
-  iterationCount: number;
-  /** Details of each iteration */
-  iterations: IIterationState[];
-  /** Total API calls made */
-  apiCallCount: number;
-  /** Total duration in ms */
-  totalDuration: number;
-}
-
-// Export DiffProcessor types
-export type { IDiffFileInfo, IProcessedDiff, IDiffProcessorOptions } from './diff-processor.js';