@git.zone/tsdoc 1.5.1 → 1.6.0

package/dist_ts/context/enhanced-context.js

@@ -1,6 +1,9 @@
 import * as plugins from '../plugins.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
  */
@@ -23,6 +26,9 @@ export class EnhancedContext {
         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
@@ -31,6 +37,7 @@ export class EnhancedContext {
         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
@@ -97,9 +104,23 @@ export class EnhancedContext {
         };
         let totalTokenCount = 0;
         let totalOriginalTokens = 0;
-        // Sort files by importance (for now just a simple alphabetical sort)
-        // Later this could be enhanced with more sophisticated prioritization
-        const sortedFiles = [...files].sort((a, b) => a.relative.localeCompare(b.relative));
+        // Convert SmartFile objects to IFileMetadata for analysis
+        const metadata = files.map(sf => ({
+            path: sf.path,
+            relativePath: sf.relative,
+            size: sf.contents.toString().length,
+            mtime: Date.now(), // SmartFile doesn't expose mtime, use current time
+            estimatedTokens: this.countTokens(sf.contents.toString()),
+            importanceScore: 0
+        }));
+        // Analyze files using ContextAnalyzer to get smart prioritization
+        // (Note: This requires task type which we'll pass from buildContext)
+        // For now, sort files by estimated tokens (smaller files first for better efficiency)
+        const sortedFiles = [...files].sort((a, b) => {
+            const aTokens = this.countTokens(a.contents.toString());
+            const bTokens = this.countTokens(b.contents.toString());
+            return aTokens - bTokens;
+        });
         const processedFiles = [];
         for (const smartfile of sortedFiles) {
             // Calculate original token count
@@ -156,6 +177,128 @@ ${processedContent}
         this.contextResult.tokenCount = totalTokenCount;
         return context;
     }
+    /**
+     * 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
+     */
+    async convertFilesToContextWithAnalysis(metadata, taskType, mode = this.contextMode) {
+        // 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 = [];
+        // Load files with cache support
+        for (const fileAnalysis of relevantFiles) {
+            try {
+                // Check cache first
+                let contents;
+                let originalTokenCount;
+                const cached = await this.cache.get(fileAnalysis.path);
+                if (cached) {
+                    contents = cached.contents;
+                    originalTokenCount = cached.tokenCount;
+                }
+                else {
+                    // Load file
+                    const fileData = await plugins.smartfile.fs.toStringSync(fileAnalysis.path);
+                    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 = '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 = {
+                    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
      * @param taskType Optional task type for task-specific context
@@ -172,39 +315,64 @@ ${processedContent}
                 this.setContextMode(taskConfig.mode);
             }
         }
-        // Gather files
-        const taskConfig = taskType ? this.configManager.getTaskConfig(taskType) : undefined;
-        const files = await this.gatherFiles(taskConfig?.includePaths, taskConfig?.excludePaths);
-        // Convert files to context
-        // Create an array of all files to process
-        const allFiles = [];
-        // Add individual files
-        if (files.smartfilePackageJSON)
-            allFiles.push(files.smartfilePackageJSON);
-        if (files.smartfilesReadme)
-            allFiles.push(files.smartfilesReadme);
-        if (files.smartfilesReadmeHints)
-            allFiles.push(files.smartfilesReadmeHints);
-        if (files.smartfilesNpmextraJSON)
-            allFiles.push(files.smartfilesNpmextraJSON);
-        // Add arrays of files
-        if (files.smartfilesMod) {
-            if (Array.isArray(files.smartfilesMod)) {
-                allFiles.push(...files.smartfilesMod);
-            }
-            else {
-                allFiles.push(files.smartfilesMod);
-            }
+        // Check if analyzer is enabled in config
+        const analyzerConfig = this.configManager.getAnalyzerConfig();
+        const useAnalyzer = analyzerConfig.enabled && taskType;
+        if (useAnalyzer) {
+            // Use new smart context building with lazy loading and analysis
+            const taskConfig = this.configManager.getTaskConfig(taskType);
+            // 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 analyzer to build context with smart prioritization
+            await this.convertFilesToContextWithAnalysis(metadata, taskType, this.contextMode);
         }
-        if (files.smartfilesTest) {
-            if (Array.isArray(files.smartfilesTest)) {
-                allFiles.push(...files.smartfilesTest);
+        else {
+            // Fall back to old method for backward compatibility
+            const taskConfig = taskType ? this.configManager.getTaskConfig(taskType) : undefined;
+            const files = await this.gatherFiles(taskConfig?.includePaths, taskConfig?.excludePaths);
+            // Convert files to context
+            // Create an array of all files to process
+            const allFiles = [];
+            // Add individual files
+            if (files.smartfilePackageJSON)
+                allFiles.push(files.smartfilePackageJSON);
+            if (files.smartfilesReadme)
+                allFiles.push(files.smartfilesReadme);
+            if (files.smartfilesReadmeHints)
+                allFiles.push(files.smartfilesReadmeHints);
+            if (files.smartfilesNpmextraJSON)
+                allFiles.push(files.smartfilesNpmextraJSON);
+            // Add arrays of files
+            if (files.smartfilesMod) {
+                if (Array.isArray(files.smartfilesMod)) {
+                    allFiles.push(...files.smartfilesMod);
+                }
+                else {
+                    allFiles.push(files.smartfilesMod);
+                }
             }
-            else {
-                allFiles.push(files.smartfilesTest);
+            if (files.smartfilesTest) {
+                if (Array.isArray(files.smartfilesTest)) {
+                    allFiles.push(...files.smartfilesTest);
+                }
+                else {
+                    allFiles.push(files.smartfilesTest);
+                }
             }
+            await this.convertFilesToContext(allFiles);
         }
-        const context = await this.convertFilesToContext(allFiles);
         return this.contextResult;
     }
     /**
@@ -269,4 +437,4 @@ ${gitDiff}
         };
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"enhanced-context.js","sourceRoot":"","sources":["../../ts/context/enhanced-context.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"enhanced-context.js","sourceRoot":"","sources":["../../ts/context/enhanced-context.ts"],"names":[],"mappings":"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"}

package/dist_ts/context/index.d.ts

@@ -2,6 +2,9 @@ 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 type { ContextMode, IContextConfig, IContextResult, IFileInfo, ITrimConfig, ITaskConfig, TaskType } from './types.js';
-export { EnhancedContext, TaskContextFactory, ConfigManager, ContextTrimmer, };
-export type { ContextMode, IContextConfig, IContextResult, IFileInfo, ITrimConfig, ITaskConfig, TaskType };
+import { LazyFileLoader } from './lazy-file-loader.js';
+import { ContextCache } from './context-cache.js';
+import { ContextAnalyzer } from './context-analyzer.js';
+import type { ContextMode, IContextConfig, IContextResult, IFileInfo, ITrimConfig, ITaskConfig, TaskType, ICacheConfig, IAnalyzerConfig, IPrioritizationWeights, ITierConfig, ITierSettings, IFileMetadata, ICacheEntry, IFileDependencies, IFileAnalysis, IAnalysisResult } from './types.js';
+export { EnhancedContext, TaskContextFactory, ConfigManager, ContextTrimmer, LazyFileLoader, ContextCache, ContextAnalyzer, };
+export type { ContextMode, IContextConfig, IContextResult, IFileInfo, ITrimConfig, ITaskConfig, TaskType, ICacheConfig, IAnalyzerConfig, IPrioritizationWeights, ITierConfig, ITierSettings, IFileMetadata, ICacheEntry, IFileDependencies, IFileAnalysis, IAnalysisResult };

package/dist_ts/context/index.js

@@ -2,7 +2,10 @@ 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';
 export { 
 // Classes
-EnhancedContext, TaskContextFactory, ConfigManager, ContextTrimmer, };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9jb250ZXh0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUN4RCxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUMvRCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDcEQsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBV3RELE9BQU87QUFDTCxVQUFVO0FBQ1YsZUFBZSxFQUNmLGtCQUFrQixFQUNsQixhQUFhLEVBQ2IsY0FBYyxHQUNmLENBQUMifQ==
+EnhancedContext, TaskContextFactory, ConfigManager, ContextTrimmer, LazyFileLoader, ContextCache, ContextAnalyzer, };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9jb250ZXh0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUN4RCxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUMvRCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDcEQsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQ3RELE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUN2RCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDbEQsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBcUJ4RCxPQUFPO0FBQ0wsVUFBVTtBQUNWLGVBQWUsRUFDZixrQkFBa0IsRUFDbEIsYUFBYSxFQUNiLGNBQWMsRUFDZCxjQUFjLEVBQ2QsWUFBWSxFQUNaLGVBQWUsR0FDaEIsQ0FBQyJ9

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

@@ -0,0 +1,60 @@
+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 declare class LazyFileLoader {
+    private projectRoot;
+    private metadataCache;
+    /**
+     * Creates a new LazyFileLoader
+     * @param projectRoot - Root directory of the project
+     */
+    constructor(projectRoot: string);
+    /**
+     * 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
+     */
+    scanFiles(globs: string[]): Promise<IFileMetadata[]>;
+    /**
+     * Gets metadata for a single file without loading contents
+     * @param filePath - Absolute path to the file
+     * @returns File metadata
+     */
+    getMetadata(filePath: string): Promise<IFileMetadata>;
+    /**
+     * 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
+     */
+    loadFiles(metadata: IFileMetadata[], tokenizer: (content: string) => number): Promise<IFileInfo[]>;
+    /**
+     * 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
+     */
+    loadFile(filePath: string, tokenizer: (content: string) => number): Promise<IFileInfo>;
+    /**
+     * Updates importance scores for metadata entries
+     * @param scores - Map of file paths to importance scores
+     */
+    updateImportanceScores(scores: Map<string, number>): void;
+    /**
+     * Clears the metadata cache
+     */
+    clearCache(): void;
+    /**
+     * Gets total estimated tokens for all cached metadata
+     */
+    getTotalEstimatedTokens(): number;
+    /**
+     * Gets cached metadata entries
+     */
+    getCachedMetadata(): IFileMetadata[];
+}

package/dist_ts/context/lazy-file-loader.js

@@ -0,0 +1,164 @@
+import * as plugins from '../plugins.js';
+import * as fs from 'fs';
+/**
+ * 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 {
+    /**
+     * Creates a new LazyFileLoader
+     * @param projectRoot - Root directory of the project
+     */
+    constructor(projectRoot) {
+        this.metadataCache = new Map();
+        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
+     */
+    async scanFiles(globs) {
+        const metadata = [];
+        for (const globPattern of globs) {
+            try {
+                const smartFiles = await plugins.smartfile.fs.fileTreeToObject(this.projectRoot, globPattern);
+                const fileArray = Array.isArray(smartFiles) ? smartFiles : [smartFiles];
+                for (const smartFile of fileArray) {
+                    try {
+                        const meta = await this.getMetadata(smartFile.path);
+                        metadata.push(meta);
+                    }
+                    catch (error) {
+                        // Skip files that can't be read
+                        console.warn(`Failed to get metadata for ${smartFile.path}:`, 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
+     */
+    async getMetadata(filePath) {
+        // 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 = {
+            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
+     */
+    async loadFiles(metadata, tokenizer) {
+        // Load files in parallel
+        const loadPromises = metadata.map(async (meta) => {
+            try {
+                const contents = await plugins.smartfile.fs.toStringSync(meta.path);
+                const tokenCount = tokenizer(contents);
+                const fileInfo = {
+                    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 !== 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
+     */
+    async loadFile(filePath, tokenizer) {
+        const meta = await this.getMetadata(filePath);
+        const contents = await plugins.smartfile.fs.toStringSync(filePath);
+        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
+     */
+    updateImportanceScores(scores) {
+        for (const [path, score] of scores) {
+            const meta = this.metadataCache.get(path);
+            if (meta) {
+                meta.importanceScore = score;
+            }
+        }
+    }
+    /**
+     * Clears the metadata cache
+     */
+    clearCache() {
+        this.metadataCache.clear();
+    }
+    /**
+     * Gets total estimated tokens for all cached metadata
+     */
+    getTotalEstimatedTokens() {
+        let total = 0;
+        for (const meta of this.metadataCache.values()) {
+            total += meta.estimatedTokens;
+        }
+        return total;
+    }
+    /**
+     * Gets cached metadata entries
+     */
+    getCachedMetadata() {
+        return Array.from(this.metadataCache.values());
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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