@git.zone/tsdoc 1.11.1 → 1.11.2

package/ts/context/context-analyzer.ts

@@ -1,391 +0,0 @@
-import * as plugins from '../plugins.js';
-import type {
-  IFileMetadata,
-  IFileDependencies,
-  IFileAnalysis,
-  IAnalysisResult,
-  TaskType,
-  IPrioritizationWeights,
-  ITierConfig,
-} from './types.js';
-
-/**
- * ContextAnalyzer provides intelligent file selection and prioritization
- * based on dependency analysis, task relevance, and configurable weights
- */
-export class ContextAnalyzer {
-  private projectRoot: string;
-  private weights: Required<IPrioritizationWeights>;
-  private tiers: Required<ITierConfig>;
-
-  /**
-   * Creates a new ContextAnalyzer
-   * @param projectRoot - Root directory of the project
-   * @param weights - Prioritization weights
-   * @param tiers - Tier configuration
-   */
-  constructor(
-    projectRoot: string,
-    weights: Partial<IPrioritizationWeights> = {},
-    tiers: Partial<ITierConfig> = {}
-  ) {
-    this.projectRoot = projectRoot;
-
-    // Default weights
-    this.weights = {
-      dependencyWeight: weights.dependencyWeight ?? 0.3,
-      relevanceWeight: weights.relevanceWeight ?? 0.4,
-      efficiencyWeight: weights.efficiencyWeight ?? 0.2,
-      recencyWeight: weights.recencyWeight ?? 0.1,
-    };
-
-    // Default tiers
-    this.tiers = {
-      essential: tiers.essential ?? { minScore: 0.8, trimLevel: 'none' },
-      important: tiers.important ?? { minScore: 0.5, trimLevel: 'light' },
-      optional: tiers.optional ?? { minScore: 0.2, trimLevel: 'aggressive' },
-    };
-  }
-
-  /**
-   * Analyzes files for a specific task type
-   * @param metadata - Array of file metadata to analyze
-   * @param taskType - Type of task being performed
-   * @param changedFiles - Optional list of recently changed files (for commits)
-   * @returns Analysis result with scored files
-   */
-  public async analyze(
-    metadata: IFileMetadata[],
-    taskType: TaskType,
-    changedFiles: string[] = []
-  ): Promise<IAnalysisResult> {
-    const startTime = Date.now();
-
-    // Build dependency graph
-    const dependencyGraph = await this.buildDependencyGraph(metadata);
-
-    // Calculate centrality scores
-    this.calculateCentrality(dependencyGraph);
-
-    // Analyze each file
-    const files: IFileAnalysis[] = [];
-    for (const meta of metadata) {
-      const analysis = await this.analyzeFile(
-        meta,
-        taskType,
-        dependencyGraph,
-        changedFiles
-      );
-      files.push(analysis);
-    }
-
-    // Sort by importance score (highest first)
-    files.sort((a, b) => b.importanceScore - a.importanceScore);
-
-    const analysisDuration = Date.now() - startTime;
-
-    return {
-      taskType,
-      files,
-      dependencyGraph,
-      totalFiles: metadata.length,
-      analysisDuration,
-    };
-  }
-
-  /**
-   * Builds a dependency graph from file metadata
-   * @param metadata - Array of file metadata
-   * @returns Dependency graph as a map
-   */
-  private async buildDependencyGraph(
-    metadata: IFileMetadata[]
-  ): Promise<Map<string, IFileDependencies>> {
-    const graph = new Map<string, IFileDependencies>();
-
-    // Initialize graph entries
-    for (const meta of metadata) {
-      graph.set(meta.path, {
-        path: meta.path,
-        imports: [],
-        importedBy: [],
-        centrality: 0,
-      });
-    }
-
-    // Parse imports from each file
-    for (const meta of metadata) {
-      try {
-        const contents = await plugins.fsInstance.file(meta.path).encoding('utf8').read() as string;
-        const imports = this.extractImports(contents, meta.path);
-
-        const deps = graph.get(meta.path)!;
-        deps.imports = imports;
-
-        // Update importedBy for imported files
-        for (const importPath of imports) {
-          const importedDeps = graph.get(importPath);
-          if (importedDeps) {
-            importedDeps.importedBy.push(meta.path);
-          }
-        }
-      } catch (error) {
-        console.warn(`Failed to parse imports from ${meta.path}:`, error.message);
-      }
-    }
-
-    return graph;
-  }
-
-  /**
-   * Extracts import statements from file contents
-   * @param contents - File contents
-   * @param filePath - Path of the file being analyzed
-   * @returns Array of absolute paths to imported files
-   */
-  private extractImports(contents: string, filePath: string): string[] {
-    const imports: string[] = [];
-    const fileDir = plugins.path.dirname(filePath);
-
-    // Match various import patterns
-    const importRegex = /(?:import|export).*?from\s+['"](.+?)['"]/g;
-    let match;
-
-    while ((match = importRegex.exec(contents)) !== null) {
-      const importPath = match[1];
-
-      // Skip external modules
-      if (!importPath.startsWith('.')) {
-        continue;
-      }
-
-      // Resolve relative import to absolute path
-      let resolvedPath = plugins.path.resolve(fileDir, importPath);
-
-      // Handle various file extensions
-      const extensions = ['.ts', '.js', '.tsx', '.jsx', '/index.ts', '/index.js'];
-      let found = false;
-
-      for (const ext of extensions) {
-        const testPath = resolvedPath.endsWith(ext) ? resolvedPath : resolvedPath + ext;
-        try {
-          // Use synchronous file check to avoid async in this context
-          const fs = require('fs');
-          const exists = fs.existsSync(testPath);
-          if (exists) {
-            imports.push(testPath);
-            found = true;
-            break;
-          }
-        } catch (error) {
-          // Continue trying other extensions
-        }
-      }
-
-      if (!found && !resolvedPath.includes('.')) {
-        // Try with .ts extension as default
-        imports.push(resolvedPath + '.ts');
-      }
-    }
-
-    return imports;
-  }
-
-  /**
-   * Calculates centrality scores for all nodes in the dependency graph
-   * Uses a simplified PageRank-like algorithm
-   * @param graph - Dependency graph
-   */
-  private calculateCentrality(graph: Map<string, IFileDependencies>): void {
-    const damping = 0.85;
-    const iterations = 10;
-    const nodeCount = graph.size;
-
-    // Initialize scores
-    const scores = new Map<string, number>();
-    for (const path of graph.keys()) {
-      scores.set(path, 1.0 / nodeCount);
-    }
-
-    // Iterative calculation
-    for (let i = 0; i < iterations; i++) {
-      const newScores = new Map<string, number>();
-
-      for (const [path, deps] of graph.entries()) {
-        let score = (1 - damping) / nodeCount;
-
-        // Add contributions from nodes that import this file
-        for (const importerPath of deps.importedBy) {
-          const importerDeps = graph.get(importerPath);
-          if (importerDeps) {
-            const importerScore = scores.get(importerPath) ?? 0;
-            const outgoingCount = importerDeps.imports.length || 1;
-            score += damping * (importerScore / outgoingCount);
-          }
-        }
-
-        newScores.set(path, score);
-      }
-
-      // Update scores
-      for (const [path, score] of newScores) {
-        scores.set(path, score);
-      }
-    }
-
-    // Normalize scores to 0-1 range
-    const maxScore = Math.max(...scores.values());
-    if (maxScore > 0) {
-      for (const deps of graph.values()) {
-        const score = scores.get(deps.path) ?? 0;
-        deps.centrality = score / maxScore;
-      }
-    }
-  }
-
-  /**
-   * Analyzes a single file
-   * @param meta - File metadata
-   * @param taskType - Task being performed
-   * @param graph - Dependency graph
-   * @param changedFiles - Recently changed files
-   * @returns File analysis
-   */
-  private async analyzeFile(
-    meta: IFileMetadata,
-    taskType: TaskType,
-    graph: Map<string, IFileDependencies>,
-    changedFiles: string[]
-  ): Promise<IFileAnalysis> {
-    const deps = graph.get(meta.path);
-    const centralityScore = deps?.centrality ?? 0;
-
-    // Calculate task-specific relevance
-    const relevanceScore = this.calculateRelevance(meta, taskType);
-
-    // Calculate efficiency (information per token)
-    const efficiencyScore = this.calculateEfficiency(meta);
-
-    // Calculate recency (for commit tasks)
-    const recencyScore = this.calculateRecency(meta, changedFiles);
-
-    // Calculate combined importance score
-    const importanceScore =
-      relevanceScore * this.weights.relevanceWeight +
-      centralityScore * this.weights.dependencyWeight +
-      efficiencyScore * this.weights.efficiencyWeight +
-      recencyScore * this.weights.recencyWeight;
-
-    // Assign tier
-    const tier = this.assignTier(importanceScore);
-
-    return {
-      path: meta.path,
-      relevanceScore,
-      centralityScore,
-      efficiencyScore,
-      recencyScore,
-      importanceScore,
-      tier,
-      reason: this.generateReason(meta, taskType, importanceScore, tier),
-    };
-  }
-
-  /**
-   * Calculates task-specific relevance score
-   */
-  private calculateRelevance(meta: IFileMetadata, taskType: TaskType): number {
-    const relativePath = meta.relativePath.toLowerCase();
-    let score = 0.5; // Base score
-
-    // README generation - prioritize public APIs and main exports
-    if (taskType === 'readme') {
-      if (relativePath.includes('index.ts')) score += 0.3;
-      if (relativePath.match(/^ts\/[^\/]+\.ts$/)) score += 0.2; // Root level exports
-      if (relativePath.includes('test/')) score -= 0.3;
-      if (relativePath.includes('classes/')) score += 0.1;
-      if (relativePath.includes('interfaces/')) score += 0.1;
-    }
-
-    // Commit messages - prioritize changed files and their dependencies
-    if (taskType === 'commit') {
-      if (relativePath.includes('test/')) score -= 0.2;
-      // Recency will handle changed files
-    }
-
-    // Description generation - prioritize main exports and core interfaces
-    if (taskType === 'description') {
-      if (relativePath.includes('index.ts')) score += 0.4;
-      if (relativePath.match(/^ts\/[^\/]+\.ts$/)) score += 0.3;
-      if (relativePath.includes('test/')) score -= 0.4;
-      if (relativePath.includes('interfaces/')) score += 0.2;
-    }
-
-    return Math.max(0, Math.min(1, score));
-  }
-
-  /**
-   * Calculates efficiency score (information density)
-   */
-  private calculateEfficiency(meta: IFileMetadata): number {
-    // Prefer files that are not too large (good signal-to-noise ratio)
-    const optimalSize = 5000; // ~1250 tokens
-    const distance = Math.abs(meta.estimatedTokens - optimalSize);
-    const normalized = Math.max(0, 1 - distance / optimalSize);
-
-    return normalized;
-  }
-
-  /**
-   * Calculates recency score for changed files
-   */
-  private calculateRecency(meta: IFileMetadata, changedFiles: string[]): number {
-    if (changedFiles.length === 0) {
-      return 0;
-    }
-
-    // Check if this file was changed
-    const isChanged = changedFiles.some((changed) => changed === meta.path);
-
-    return isChanged ? 1.0 : 0.0;
-  }
-
-  /**
-   * Assigns a tier based on importance score
-   */
-  private assignTier(score: number): 'essential' | 'important' | 'optional' | 'excluded' {
-    if (score >= this.tiers.essential.minScore) return 'essential';
-    if (score >= this.tiers.important.minScore) return 'important';
-    if (score >= this.tiers.optional.minScore) return 'optional';
-    return 'excluded';
-  }
-
-  /**
-   * Generates a human-readable reason for the score
-   */
-  private generateReason(
-    meta: IFileMetadata,
-    taskType: TaskType,
-    score: number,
-    tier: string
-  ): string {
-    const reasons: string[] = [];
-
-    if (meta.relativePath.includes('index.ts')) {
-      reasons.push('main export file');
-    }
-
-    if (meta.relativePath.includes('test/')) {
-      reasons.push('test file (lower priority)');
-    }
-
-    if (taskType === 'readme' && meta.relativePath.match(/^ts\/[^\/]+\.ts$/)) {
-      reasons.push('root-level module');
-    }
-
-    reasons.push(`score: ${score.toFixed(2)}`);
-    reasons.push(`tier: ${tier}`);
-
-    return reasons.join(', ');
-  }
-}

package/ts/context/context-cache.ts

@@ -1,286 +0,0 @@
-import * as plugins from '../plugins.js';
-import * as fs from 'fs';
-import type { ICacheEntry, ICacheConfig } from './types.js';
-import { logger } from '../logging.js';
-
-/**
- * ContextCache provides persistent caching of file contents and token counts
- * with automatic invalidation on file changes
- */
-export class ContextCache {
-  private cacheDir: string;
-  private cache: Map<string, ICacheEntry> = new Map();
-  private config: Required<ICacheConfig>;
-  private cacheIndexPath: string;
-
-  /**
-   * Creates a new ContextCache
-   * @param projectRoot - Root directory of the project
-   * @param config - Cache configuration
-   */
-  constructor(projectRoot: string, config: Partial<ICacheConfig> = {}) {
-    this.config = {
-      enabled: config.enabled ?? true,
-      ttl: config.ttl ?? 3600, // 1 hour default
-      maxSize: config.maxSize ?? 100, // 100MB default
-      directory: config.directory ?? plugins.path.join(projectRoot, '.nogit', 'context-cache'),
-    };
-
-    this.cacheDir = this.config.directory;
-    this.cacheIndexPath = plugins.path.join(this.cacheDir, 'index.json');
-  }
-
-  /**
-   * Initializes the cache by loading from disk
-   */
-  public async init(): Promise<void> {
-    if (!this.config.enabled) {
-      return;
-    }
-
-    // Ensure cache directory exists
-    await plugins.fsInstance.directory(this.cacheDir).recursive().create();
-
-    // Load cache index if it exists
-    try {
-      const indexExists = await plugins.fsInstance.file(this.cacheIndexPath).exists();
-      if (indexExists) {
-        const indexContent = await plugins.fsInstance.file(this.cacheIndexPath).encoding('utf8').read() as string;
-        const indexData = JSON.parse(indexContent) as ICacheEntry[];
-        if (Array.isArray(indexData)) {
-          for (const entry of indexData) {
-            this.cache.set(entry.path, entry);
-          }
-        }
-      }
-    } catch (error) {
-      console.warn('Failed to load cache index:', error.message);
-      // Start with empty cache if loading fails
-    }
-
-    // Clean up expired and invalid entries
-    await this.cleanup();
-  }
-
-  /**
-   * Gets a cached entry if it's still valid
-   * @param filePath - Absolute path to the file
-   * @returns Cache entry if valid, null otherwise
-   */
-  public async get(filePath: string): Promise<ICacheEntry | null> {
-    if (!this.config.enabled) {
-      return null;
-    }
-
-    const entry = this.cache.get(filePath);
-    if (!entry) {
-      return null;
-    }
-
-    // Check if entry is expired
-    const now = Date.now();
-    if (now - entry.cachedAt > this.config.ttl * 1000) {
-      this.cache.delete(filePath);
-      return null;
-    }
-
-    // Check if file has been modified
-    try {
-      const stats = await fs.promises.stat(filePath);
-      const currentMtime = Math.floor(stats.mtimeMs);
-
-      if (currentMtime !== entry.mtime) {
-        // File has changed, invalidate cache
-        this.cache.delete(filePath);
-        return null;
-      }
-
-      return entry;
-    } catch (error) {
-      // File doesn't exist anymore
-      this.cache.delete(filePath);
-      return null;
-    }
-  }
-
-  /**
-   * Stores a cache entry
-   * @param entry - Cache entry to store
-   */
-  public async set(entry: ICacheEntry): Promise<void> {
-    if (!this.config.enabled) {
-      return;
-    }
-
-    this.cache.set(entry.path, entry);
-
-    // Check cache size and evict old entries if needed
-    await this.enforceMaxSize();
-
-    // Persist to disk (async, don't await)
-    this.persist().catch((error) => {
-      console.warn('Failed to persist cache:', error.message);
-    });
-  }
-
-  /**
-   * Stores multiple cache entries
-   * @param entries - Array of cache entries
-   */
-  public async setMany(entries: ICacheEntry[]): Promise<void> {
-    if (!this.config.enabled) {
-      return;
-    }
-
-    for (const entry of entries) {
-      this.cache.set(entry.path, entry);
-    }
-
-    await this.enforceMaxSize();
-    await this.persist();
-  }
-
-  /**
-   * Checks if a file is cached and valid
-   * @param filePath - Absolute path to the file
-   * @returns True if cached and valid
-   */
-  public async has(filePath: string): Promise<boolean> {
-    const entry = await this.get(filePath);
-    return entry !== null;
-  }
-
-  /**
-   * Gets cache statistics
-   */
-  public getStats(): {
-    entries: number;
-    totalSize: number;
-    oldestEntry: number | null;
-    newestEntry: number | null;
-  } {
-    let totalSize = 0;
-    let oldestEntry: number | null = null;
-    let newestEntry: number | null = null;
-
-    for (const entry of this.cache.values()) {
-      totalSize += entry.contents.length;
-
-      if (oldestEntry === null || entry.cachedAt < oldestEntry) {
-        oldestEntry = entry.cachedAt;
-      }
-
-      if (newestEntry === null || entry.cachedAt > newestEntry) {
-        newestEntry = entry.cachedAt;
-      }
-    }
-
-    return {
-      entries: this.cache.size,
-      totalSize,
-      oldestEntry,
-      newestEntry,
-    };
-  }
-
-  /**
-   * Clears all cache entries
-   */
-  public async clear(): Promise<void> {
-    this.cache.clear();
-    await this.persist();
-  }
-
-  /**
-   * Clears specific cache entries
-   * @param filePaths - Array of file paths to clear
-   */
-  public async clearPaths(filePaths: string[]): Promise<void> {
-    for (const path of filePaths) {
-      this.cache.delete(path);
-    }
-    await this.persist();
-  }
-
-  /**
-   * Cleans up expired and invalid cache entries
-   */
-  private async cleanup(): Promise<void> {
-    const now = Date.now();
-    const toDelete: string[] = [];
-
-    for (const [path, entry] of this.cache.entries()) {
-      // Check expiration
-      if (now - entry.cachedAt > this.config.ttl * 1000) {
-        toDelete.push(path);
-        continue;
-      }
-
-      // Check if file still exists and hasn't changed
-      try {
-        const stats = await fs.promises.stat(path);
-        const currentMtime = Math.floor(stats.mtimeMs);
-
-        if (currentMtime !== entry.mtime) {
-          toDelete.push(path);
-        }
-      } catch (error) {
-        // File doesn't exist
-        toDelete.push(path);
-      }
-    }
-
-    for (const path of toDelete) {
-      this.cache.delete(path);
-    }
-
-    if (toDelete.length > 0) {
-      await this.persist();
-    }
-  }
-
-  /**
-   * Enforces maximum cache size by evicting oldest entries
-   */
-  private async enforceMaxSize(): Promise<void> {
-    const stats = this.getStats();
-    const maxSizeBytes = this.config.maxSize * 1024 * 1024; // Convert MB to bytes
-
-    if (stats.totalSize <= maxSizeBytes) {
-      return;
-    }
-
-    // Sort entries by age (oldest first)
-    const entries = Array.from(this.cache.entries()).sort(
-      (a, b) => a[1].cachedAt - b[1].cachedAt
-    );
-
-    // Remove oldest entries until we're under the limit
-    let currentSize = stats.totalSize;
-    for (const [path, entry] of entries) {
-      if (currentSize <= maxSizeBytes) {
-        break;
-      }
-
-      currentSize -= entry.contents.length;
-      this.cache.delete(path);
-    }
-  }
-
-  /**
-   * Persists cache index to disk
-   */
-  private async persist(): Promise<void> {
-    if (!this.config.enabled) {
-      return;
-    }
-
-    try {
-      const entries = Array.from(this.cache.values());
-      const content = JSON.stringify(entries, null, 2);
-      await plugins.fsInstance.file(this.cacheIndexPath).encoding('utf8').write(content);
-    } catch (error) {
-      console.warn('Failed to persist cache index:', error.message);
-    }
-  }
-}