@git.zone/tsdoc 1.5.2 → 1.6.1

package/dist_ts/context/context-cache.d.ts

@@ -0,0 +1,73 @@
+import type { ICacheEntry, ICacheConfig } from './types.js';
+/**
+ * ContextCache provides persistent caching of file contents and token counts
+ * with automatic invalidation on file changes
+ */
+export declare class ContextCache {
+    private cacheDir;
+    private cache;
+    private config;
+    private cacheIndexPath;
+    /**
+     * Creates a new ContextCache
+     * @param projectRoot - Root directory of the project
+     * @param config - Cache configuration
+     */
+    constructor(projectRoot: string, config?: Partial<ICacheConfig>);
+    /**
+     * Initializes the cache by loading from disk
+     */
+    init(): Promise<void>;
+    /**
+     * Gets a cached entry if it's still valid
+     * @param filePath - Absolute path to the file
+     * @returns Cache entry if valid, null otherwise
+     */
+    get(filePath: string): Promise<ICacheEntry | null>;
+    /**
+     * Stores a cache entry
+     * @param entry - Cache entry to store
+     */
+    set(entry: ICacheEntry): Promise<void>;
+    /**
+     * Stores multiple cache entries
+     * @param entries - Array of cache entries
+     */
+    setMany(entries: ICacheEntry[]): Promise<void>;
+    /**
+     * Checks if a file is cached and valid
+     * @param filePath - Absolute path to the file
+     * @returns True if cached and valid
+     */
+    has(filePath: string): Promise<boolean>;
+    /**
+     * Gets cache statistics
+     */
+    getStats(): {
+        entries: number;
+        totalSize: number;
+        oldestEntry: number | null;
+        newestEntry: number | null;
+    };
+    /**
+     * Clears all cache entries
+     */
+    clear(): Promise<void>;
+    /**
+     * Clears specific cache entries
+     * @param filePaths - Array of file paths to clear
+     */
+    clearPaths(filePaths: string[]): Promise<void>;
+    /**
+     * Cleans up expired and invalid cache entries
+     */
+    private cleanup;
+    /**
+     * Enforces maximum cache size by evicting oldest entries
+     */
+    private enforceMaxSize;
+    /**
+     * Persists cache index to disk
+     */
+    private persist;
+}

package/dist_ts/context/context-cache.js

@@ -0,0 +1,238 @@
+import * as plugins from '../plugins.js';
+import * as fs from 'fs';
+/**
+ * ContextCache provides persistent caching of file contents and token counts
+ * with automatic invalidation on file changes
+ */
+export class ContextCache {
+    /**
+     * Creates a new ContextCache
+     * @param projectRoot - Root directory of the project
+     * @param config - Cache configuration
+     */
+    constructor(projectRoot, config = {}) {
+        this.cache = new Map();
+        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
+     */
+    async init() {
+        if (!this.config.enabled) {
+            return;
+        }
+        // Ensure cache directory exists
+        await plugins.smartfile.fs.ensureDir(this.cacheDir);
+        // Load cache index if it exists
+        try {
+            const indexExists = await plugins.smartfile.fs.fileExists(this.cacheIndexPath);
+            if (indexExists) {
+                const indexContent = await plugins.smartfile.fs.toStringSync(this.cacheIndexPath);
+                const indexData = JSON.parse(indexContent);
+                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
+     */
+    async get(filePath) {
+        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
+     */
+    async set(entry) {
+        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
+     */
+    async setMany(entries) {
+        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
+     */
+    async has(filePath) {
+        const entry = await this.get(filePath);
+        return entry !== null;
+    }
+    /**
+     * Gets cache statistics
+     */
+    getStats() {
+        let totalSize = 0;
+        let oldestEntry = null;
+        let newestEntry = 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
+     */
+    async clear() {
+        this.cache.clear();
+        await this.persist();
+    }
+    /**
+     * Clears specific cache entries
+     * @param filePaths - Array of file paths to clear
+     */
+    async clearPaths(filePaths) {
+        for (const path of filePaths) {
+            this.cache.delete(path);
+        }
+        await this.persist();
+    }
+    /**
+     * Cleans up expired and invalid cache entries
+     */
+    async cleanup() {
+        const now = Date.now();
+        const toDelete = [];
+        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
+     */
+    async enforceMaxSize() {
+        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
+     */
+    async persist() {
+        if (!this.config.enabled) {
+            return;
+        }
+        try {
+            const entries = Array.from(this.cache.values());
+            const content = JSON.stringify(entries, null, 2);
+            await plugins.smartfile.memory.toFs(content, this.cacheIndexPath);
+        }
+        catch (error) {
+            console.warn('Failed to persist cache index:', error.message);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"context-cache.js","sourceRoot":"","sources":["../../ts/context/context-cache.ts"],"names":[],"mappings":"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"}

package/dist_ts/context/context-trimmer.d.ts

@@ -49,4 +49,12 @@ export declare class ContextTrimmer {
      * @param config The new configuration to apply
      */
     updateConfig(config: ITrimConfig): void;
+    /**
+     * Trim a file based on its importance tier
+     * @param filePath The path to the file
+     * @param content The file's contents
+     * @param level The trimming level to apply ('none', 'light', 'aggressive')
+     * @returns The trimmed file contents
+     */
+    trimFileWithLevel(filePath: string, content: string, level: 'none' | 'light' | 'aggressive'): string;
 }

package/dist_ts/context/context-trimmer.js

@@ -195,5 +195,64 @@ export class ContextTrimmer {
             ...config
         };
     }
+    /**
+     * Trim a file based on its importance tier
+     * @param filePath The path to the file
+     * @param content The file's contents
+     * @param level The trimming level to apply ('none', 'light', 'aggressive')
+     * @returns The trimmed file contents
+     */
+    trimFileWithLevel(filePath, content, level) {
+        // No trimming for essential files
+        if (level === 'none') {
+            return content;
+        }
+        // Create a temporary config based on level
+        const originalConfig = { ...this.config };
+        try {
+            if (level === 'light') {
+                // Light trimming: preserve signatures, remove only complex implementations
+                this.config = {
+                    ...this.config,
+                    removeImplementations: false,
+                    preserveInterfaces: true,
+                    preserveTypeDefs: true,
+                    preserveJSDoc: true,
+                    maxFunctionLines: 10,
+                    removeComments: false,
+                    removeBlankLines: true
+                };
+            }
+            else if (level === 'aggressive') {
+                // Aggressive trimming: remove all implementations, keep only signatures
+                this.config = {
+                    ...this.config,
+                    removeImplementations: true,
+                    preserveInterfaces: true,
+                    preserveTypeDefs: true,
+                    preserveJSDoc: true,
+                    maxFunctionLines: 3,
+                    removeComments: true,
+                    removeBlankLines: true
+                };
+            }
+            // Process based on file type
+            let result = content;
+            if (filePath.endsWith('.ts') || filePath.endsWith('.tsx')) {
+                result = this.trimTypeScriptFile(content);
+            }
+            else if (filePath.endsWith('.md')) {
+                result = this.trimMarkdownFile(content);
+            }
+            else if (filePath.endsWith('.json')) {
+                result = this.trimJsonFile(content);
+            }
+            return result;
+        }
+        finally {
+            // Restore original config
+            this.config = originalConfig;
+        }
+    }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"context-trimmer.js","sourceRoot":"","sources":["../../ts/context/context-trimmer.ts"],"names":[],"mappings":"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"}

package/dist_ts/context/enhanced-context.d.ts

@@ -1,5 +1,4 @@
-import * as plugins from '../plugins.js';
-import type { ContextMode, IContextResult, TaskType } from './types.js';
+import type { ContextMode, IContextResult, TaskType, IFileMetadata } from './types.js';
 /**
  * Enhanced ProjectContext that supports context optimization strategies
  */
@@ -7,6 +6,9 @@ export declare class EnhancedContext {
     private projectDir;
     private trimmer;
     private configManager;
+    private lazyLoader;
+    private cache;
+    private analyzer;
     private contextMode;
     private tokenBudget;
     private contextResult;
@@ -30,20 +32,16 @@ export declare class EnhancedContext {
      */
     setTokenBudget(maxTokens: number): void;
     /**
-     * Gather files from the project
-     * @param includePaths Optional paths to include
-     * @param excludePaths Optional paths to exclude
+     * 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
      */
-    gatherFiles(includePaths?: string[], excludePaths?: string[]): Promise<Record<string, plugins.smartfile.SmartFile | plugins.smartfile.SmartFile[]>>;
+    convertFilesToContextWithAnalysis(metadata: IFileMetadata[], taskType: TaskType, mode?: ContextMode): Promise<string>;
     /**
-     * Convert files to context string
-     * @param files The files to convert
-     * @param mode The context mode to use
-     */
-    convertFilesToContext(files: plugins.smartfile.SmartFile[], mode?: ContextMode): Promise<string>;
-    /**
-     * Build context for the project
-     * @param taskType Optional task type for task-specific context
+     * Build context for the project using smart analysis
+     * @param taskType Task type for context-aware prioritization (defaults to 'description')
      */
     buildContext(taskType?: TaskType): Promise<IContextResult>;
     /**