@git.zone/tsdoc 1.4.5 → 1.5.1

package/dist_ts/context/config-manager.js

@@ -0,0 +1,183 @@
+import * as plugins from '../plugins.js';
+/**
+ * Manages configuration for context building
+ */
+export class ConfigManager {
+    /**
+     * Get the singleton instance of ConfigManager
+     */
+    static getInstance() {
+        if (!ConfigManager.instance) {
+            ConfigManager.instance = new ConfigManager();
+        }
+        return ConfigManager.instance;
+    }
+    /**
+     * Private constructor for singleton pattern
+     */
+    constructor() {
+        this.projectDir = '';
+        this.config = this.getDefaultConfig();
+    }
+    /**
+     * Initialize the config manager with a project directory
+     * @param projectDir The project directory
+     */
+    async initialize(projectDir) {
+        this.projectDir = projectDir;
+        await this.loadConfig();
+    }
+    /**
+     * Get the default configuration
+     */
+    getDefaultConfig() {
+        return {
+            maxTokens: 190000, // Default for o4-mini with some buffer
+            defaultMode: 'trimmed',
+            taskSpecificSettings: {
+                readme: {
+                    mode: 'trimmed',
+                    includePaths: ['ts/', 'src/'],
+                    excludePaths: ['test/', 'node_modules/']
+                },
+                commit: {
+                    mode: 'trimmed',
+                    focusOnChangedFiles: true
+                },
+                description: {
+                    mode: 'trimmed',
+                    includePackageInfo: true
+                }
+            },
+            trimming: {
+                removeImplementations: true,
+                preserveInterfaces: true,
+                preserveTypeDefs: true,
+                preserveJSDoc: true,
+                maxFunctionLines: 5,
+                removeComments: true,
+                removeBlankLines: true
+            }
+        };
+    }
+    /**
+     * Load configuration from npmextra.json
+     */
+    async loadConfig() {
+        try {
+            if (!this.projectDir) {
+                return;
+            }
+            // Create KeyValueStore for this project
+            // We'll just use smartfile directly instead of KeyValueStore
+            // Read the npmextra.json file
+            const npmextraJsonFile = await plugins.smartfile.SmartFile.fromFilePath(plugins.path.join(this.projectDir, 'npmextra.json'));
+            const npmextraContent = JSON.parse(npmextraJsonFile.contents.toString());
+            // Check for tsdoc context configuration
+            if (npmextraContent?.tsdoc?.context) {
+                // Merge with default config
+                this.config = this.mergeConfigs(this.config, npmextraContent.tsdoc.context);
+            }
+        }
+        catch (error) {
+            console.error('Error loading context configuration:', error);
+        }
+    }
+    /**
+     * Merge configurations, with userConfig taking precedence
+     * @param defaultConfig The default configuration
+     * @param userConfig The user configuration
+     */
+    mergeConfigs(defaultConfig, userConfig) {
+        const result = { ...defaultConfig };
+        // Merge top-level properties
+        if (userConfig.maxTokens !== undefined)
+            result.maxTokens = userConfig.maxTokens;
+        if (userConfig.defaultMode !== undefined)
+            result.defaultMode = userConfig.defaultMode;
+        // Merge task-specific settings
+        if (userConfig.taskSpecificSettings) {
+            result.taskSpecificSettings = result.taskSpecificSettings || {};
+            // For each task type, merge settings
+            ['readme', 'commit', 'description'].forEach(taskType => {
+                if (userConfig.taskSpecificSettings?.[taskType]) {
+                    result.taskSpecificSettings[taskType] = {
+                        ...result.taskSpecificSettings[taskType],
+                        ...userConfig.taskSpecificSettings[taskType]
+                    };
+                }
+            });
+        }
+        // Merge trimming configuration
+        if (userConfig.trimming) {
+            result.trimming = {
+                ...result.trimming,
+                ...userConfig.trimming
+            };
+        }
+        return result;
+    }
+    /**
+     * Get the complete configuration
+     */
+    getConfig() {
+        return this.config;
+    }
+    /**
+     * Get the trimming configuration
+     */
+    getTrimConfig() {
+        return this.config.trimming || {};
+    }
+    /**
+     * Get configuration for a specific task
+     * @param taskType The type of task
+     */
+    getTaskConfig(taskType) {
+        // Get task-specific config or empty object
+        const taskConfig = this.config.taskSpecificSettings?.[taskType] || {};
+        // If mode is not specified, use default mode
+        if (!taskConfig.mode) {
+            taskConfig.mode = this.config.defaultMode;
+        }
+        return taskConfig;
+    }
+    /**
+     * Get the maximum tokens allowed for context
+     */
+    getMaxTokens() {
+        return this.config.maxTokens || 190000;
+    }
+    /**
+     * Update the configuration
+     * @param config The new configuration
+     */
+    async updateConfig(config) {
+        // Merge with existing config
+        this.config = this.mergeConfigs(this.config, config);
+        try {
+            if (!this.projectDir) {
+                return;
+            }
+            // Read the existing npmextra.json file
+            const npmextraJsonPath = plugins.path.join(this.projectDir, 'npmextra.json');
+            let npmextraContent = {};
+            if (await plugins.smartfile.fs.fileExists(npmextraJsonPath)) {
+                const npmextraJsonFile = await plugins.smartfile.SmartFile.fromFilePath(npmextraJsonPath);
+                npmextraContent = JSON.parse(npmextraJsonFile.contents.toString()) || {};
+            }
+            // Update the tsdoc context configuration
+            const typedContent = npmextraContent;
+            if (!typedContent.tsdoc)
+                typedContent.tsdoc = {};
+            typedContent.tsdoc.context = this.config;
+            // Write back to npmextra.json
+            const updatedContent = JSON.stringify(npmextraContent, null, 2);
+            await plugins.smartfile.memory.toFs(updatedContent, npmextraJsonPath);
+        }
+        catch (error) {
+            console.error('Error updating context configuration:', error);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,52 @@
+import type { ITrimConfig, ContextMode } from './types.js';
+/**
+ * Class responsible for trimming file contents to reduce token usage
+ * while preserving important information for context
+ */
+export declare class ContextTrimmer {
+    private config;
+    /**
+     * Create a new ContextTrimmer with the given configuration
+     * @param config The trimming configuration
+     */
+    constructor(config?: ITrimConfig);
+    /**
+     * Trim a file's contents based on the configuration
+     * @param filePath The path to the file
+     * @param content The file's contents
+     * @param mode The context mode to use
+     * @returns The trimmed file contents
+     */
+    trimFile(filePath: string, content: string, mode?: ContextMode): string;
+    /**
+     * Trim a TypeScript file to reduce token usage
+     * @param content The TypeScript file contents
+     * @returns The trimmed file contents
+     */
+    private trimTypeScriptFile;
+    /**
+     * Limit a function body to a maximum number of lines
+     * @param start The function signature and opening brace
+     * @param body The function body
+     * @param end The closing brace
+     * @returns The limited function body
+     */
+    private limitFunctionBody;
+    /**
+     * Trim a Markdown file to reduce token usage
+     * @param content The Markdown file contents
+     * @returns The trimmed file contents
+     */
+    private trimMarkdownFile;
+    /**
+     * Trim a JSON file to reduce token usage
+     * @param content The JSON file contents
+     * @returns The trimmed file contents
+     */
+    private trimJsonFile;
+    /**
+     * Update the trimmer configuration
+     * @param config The new configuration to apply
+     */
+    updateConfig(config: ITrimConfig): void;
+}

package/dist_ts/context/context-trimmer.js

@@ -0,0 +1,199 @@
+import * as plugins from '../plugins.js';
+/**
+ * Class responsible for trimming file contents to reduce token usage
+ * while preserving important information for context
+ */
+export class ContextTrimmer {
+    /**
+     * Create a new ContextTrimmer with the given configuration
+     * @param config The trimming configuration
+     */
+    constructor(config) {
+        this.config = {
+            removeImplementations: true,
+            preserveInterfaces: true,
+            preserveTypeDefs: true,
+            preserveJSDoc: true,
+            maxFunctionLines: 5,
+            removeComments: true,
+            removeBlankLines: true,
+            ...config
+        };
+    }
+    /**
+     * Trim a file's contents based on the configuration
+     * @param filePath The path to the file
+     * @param content The file's contents
+     * @param mode The context mode to use
+     * @returns The trimmed file contents
+     */
+    trimFile(filePath, content, mode = 'trimmed') {
+        // If mode is 'full', return the original content
+        if (mode === 'full') {
+            return content;
+        }
+        // Process based on file type
+        if (filePath.endsWith('.ts') || filePath.endsWith('.tsx')) {
+            return this.trimTypeScriptFile(content);
+        }
+        else if (filePath.endsWith('.md')) {
+            return this.trimMarkdownFile(content);
+        }
+        else if (filePath.endsWith('.json')) {
+            return this.trimJsonFile(content);
+        }
+        // Default to returning the original content for unknown file types
+        return content;
+    }
+    /**
+     * Trim a TypeScript file to reduce token usage
+     * @param content The TypeScript file contents
+     * @returns The trimmed file contents
+     */
+    trimTypeScriptFile(content) {
+        let result = content;
+        // Step 1: Preserve JSDoc comments if configured
+        const jsDocComments = [];
+        if (this.config.preserveJSDoc) {
+            const jsDocRegex = /\/\*\*[\s\S]*?\*\//g;
+            const matches = result.match(jsDocRegex) || [];
+            jsDocComments.push(...matches);
+        }
+        // Step 2: Remove comments if configured
+        if (this.config.removeComments) {
+            // Remove single-line comments
+            result = result.replace(/\/\/.*$/gm, '');
+            // Remove multi-line comments (except JSDoc if preserveJSDoc is true)
+            if (!this.config.preserveJSDoc) {
+                result = result.replace(/\/\*[\s\S]*?\*\//g, '');
+            }
+            else {
+                // Only remove non-JSDoc comments
+                result = result.replace(/\/\*(?!\*)[\s\S]*?\*\//g, '');
+            }
+        }
+        // Step 3: Remove function implementations if configured
+        if (this.config.removeImplementations) {
+            // Match function and method bodies
+            result = result.replace(/(\b(function|constructor|async function)\s+[\w$]*\s*\([^)]*\)\s*{)([\s\S]*?)(})/g, (match, start, funcType, body, end) => {
+                // Keep function signature and opening brace, replace body with comment
+                return `${start} /* implementation removed */ ${end}`;
+            });
+            // Match arrow function bodies
+            result = result.replace(/(\([^)]*\)\s*=>\s*{)([\s\S]*?)(})/g, (match, start, body, end) => {
+                return `${start} /* implementation removed */ ${end}`;
+            });
+            // Match method declarations
+            result = result.replace(/(^\s*[\w$]*\s*\([^)]*\)\s*{)([\s\S]*?)(})/gm, (match, start, body, end) => {
+                return `${start} /* implementation removed */ ${end}`;
+            });
+            // Match class methods
+            result = result.replace(/(\b(public|private|protected|static|async)?\s+[\w$]+\s*\([^)]*\)\s*{)([\s\S]*?)(})/g, (match, start, modifier, body, end) => {
+                return `${start} /* implementation removed */ ${end}`;
+            });
+        }
+        else if (this.config.maxFunctionLines && this.config.maxFunctionLines > 0) {
+            // If not removing implementations completely, limit the number of lines
+            // Match function and method bodies
+            result = result.replace(/(\b(function|constructor|async function)\s+[\w$]*\s*\([^)]*\)\s*{)([\s\S]*?)(})/g, (match, start, funcType, body, end) => {
+                return this.limitFunctionBody(start, body, end);
+            });
+            // Match arrow function bodies
+            result = result.replace(/(\([^)]*\)\s*=>\s*{)([\s\S]*?)(})/g, (match, start, body, end) => {
+                return this.limitFunctionBody(start, body, end);
+            });
+            // Match method declarations
+            result = result.replace(/(^\s*[\w$]*\s*\([^)]*\)\s*{)([\s\S]*?)(})/gm, (match, start, body, end) => {
+                return this.limitFunctionBody(start, body, end);
+            });
+            // Match class methods
+            result = result.replace(/(\b(public|private|protected|static|async)?\s+[\w$]+\s*\([^)]*\)\s*{)([\s\S]*?)(})/g, (match, start, modifier, body, end) => {
+                return this.limitFunctionBody(start, body, end);
+            });
+        }
+        // Step 4: Remove blank lines if configured
+        if (this.config.removeBlankLines) {
+            result = result.replace(/^\s*[\r\n]/gm, '');
+        }
+        // Step 5: Restore preserved JSDoc comments
+        if (this.config.preserveJSDoc && jsDocComments.length > 0) {
+            // This is a placeholder; we already preserved JSDoc comments in the regex steps
+        }
+        return result;
+    }
+    /**
+     * Limit a function body to a maximum number of lines
+     * @param start The function signature and opening brace
+     * @param body The function body
+     * @param end The closing brace
+     * @returns The limited function body
+     */
+    limitFunctionBody(start, body, end) {
+        const lines = body.split('\n');
+        if (lines.length > this.config.maxFunctionLines) {
+            const limitedBody = lines.slice(0, this.config.maxFunctionLines).join('\n');
+            return `${start}${limitedBody}\n  // ... (${lines.length - this.config.maxFunctionLines} lines trimmed)\n${end}`;
+        }
+        return `${start}${body}${end}`;
+    }
+    /**
+     * Trim a Markdown file to reduce token usage
+     * @param content The Markdown file contents
+     * @returns The trimmed file contents
+     */
+    trimMarkdownFile(content) {
+        // For markdown files, we generally want to keep most content
+        // but we can remove lengthy code blocks if needed
+        return content;
+    }
+    /**
+     * Trim a JSON file to reduce token usage
+     * @param content The JSON file contents
+     * @returns The trimmed file contents
+     */
+    trimJsonFile(content) {
+        try {
+            // Parse the JSON
+            const json = JSON.parse(content);
+            // For package.json, keep only essential information
+            if ('name' in json && 'version' in json && 'dependencies' in json) {
+                const essentialKeys = [
+                    'name', 'version', 'description', 'author', 'license',
+                    'main', 'types', 'exports', 'type'
+                ];
+                const trimmedJson = {};
+                essentialKeys.forEach(key => {
+                    if (key in json) {
+                        trimmedJson[key] = json[key];
+                    }
+                });
+                // Add dependency information without versions
+                if ('dependencies' in json) {
+                    trimmedJson.dependencies = Object.keys(json.dependencies).reduce((acc, dep) => {
+                        acc[dep] = '*'; // Replace version with wildcard
+                        return acc;
+                    }, {});
+                }
+                // Return the trimmed JSON
+                return JSON.stringify(trimmedJson, null, 2);
+            }
+            // For other JSON files, leave as is
+            return content;
+        }
+        catch (error) {
+            // If there's an error parsing the JSON, return the original content
+            return content;
+        }
+    }
+    /**
+     * Update the trimmer configuration
+     * @param config The new configuration to apply
+     */
+    updateConfig(config) {
+        this.config = {
+            ...this.config,
+            ...config
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udGV4dC10cmltbWVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvY29udGV4dC9jb250ZXh0LXRyaW1tZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSxlQUFlLENBQUM7QUFHekM7OztHQUdHO0FBQ0gsTUFBTSxPQUFPLGNBQWM7SUFHekI7OztPQUdHO0lBQ0gsWUFBWSxNQUFvQjtRQUM5QixJQUFJLENBQUMsTUFBTSxHQUFHO1lBQ1oscUJBQXFCLEVBQUUsSUFBSTtZQUMzQixrQkFBa0IsRUFBRSxJQUFJO1lBQ3hCLGdCQUFnQixFQUFFLElBQUk7WUFDdEIsYUFBYSxFQUFFLElBQUk7WUFDbkIsZ0JBQWdCLEVBQUUsQ0FBQztZQUNuQixjQUFjLEVBQUUsSUFBSTtZQUNwQixnQkFBZ0IsRUFBRSxJQUFJO1lBQ3RCLEdBQUcsTUFBTTtTQUNWLENBQUM7SUFDSixDQUFDO0lBRUQ7Ozs7OztPQU1HO0lBQ0ksUUFBUSxDQUFDLFFBQWdCLEVBQUUsT0FBZSxFQUFFLE9BQW9CLFNBQVM7UUFDOUUsaURBQWlEO1FBQ2pELElBQUksSUFBSSxLQUFLLE1BQU0sRUFBRSxDQUFDO1lBQ3BCLE9BQU8sT0FBTyxDQUFDO1FBQ2pCLENBQUM7UUFFRCw2QkFBNkI7UUFDN0IsSUFBSSxRQUFRLENBQUMsUUFBUSxDQUFDLEtBQUssQ0FBQyxJQUFJLFFBQVEsQ0FBQyxRQUFRLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQztZQUMxRCxPQUFPLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUMxQyxDQUFDO2FBQU0sSUFBSSxRQUFRLENBQUMsUUFBUSxDQUFDLEtBQUssQ0FBQyxFQUFFLENBQUM7WUFDcEMsT0FBTyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDeEMsQ0FBQzthQUFNLElBQUksUUFBUSxDQUFDLFFBQVEsQ0FBQyxPQUFPLENBQUMsRUFBRSxDQUFDO1lBQ3RDLE9BQU8sSUFBSSxDQUFDLFlBQVksQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUNwQyxDQUFDO1FBRUQsbUVBQW1FO1FBQ25FLE9BQU8sT0FBTyxDQUFDO0lBQ2pCLENBQUM7SUFFRDs7OztPQUlHO0lBQ0ssa0JBQWtCLENBQUMsT0FBZTtRQUN4QyxJQUFJLE1BQU0sR0FBRyxPQUFPLENBQUM7UUFFckIsZ0RBQWdEO1FBQ2hELE1BQU0sYUFBYSxHQUFhLEVBQUUsQ0FBQztRQUNuQyxJQUFJLElBQUksQ0FBQyxNQUFNLENBQUMsYUFBYSxFQUFFLENBQUM7WUFDOUIsTUFBTSxVQUFVLEdBQUcscUJBQXFCLENBQUM7WUFDekMsTUFBTSxPQUFPLEdBQUcsTUFBTSxDQUFDLEtBQUssQ0FBQyxVQUFVLENBQUMsSUFBSSxFQUFFLENBQUM7WUFDL0MsYUFBYSxDQUFDLElBQUksQ0FBQyxHQUFHLE9BQU8sQ0FBQyxDQUFDO1FBQ2pDLENBQUM7UUFFRCx3Q0FBd0M7UUFDeEMsSUFBSSxJQUFJLENBQUMsTUFBTSxDQUFDLGNBQWMsRUFBRSxDQUFDO1lBQy9CLDhCQUE4QjtZQUM5QixNQUFNLEdBQUcsTUFBTSxDQUFDLE9BQU8sQ0FBQyxXQUFXLEVBQUUsRUFBRSxDQUFDLENBQUM7WUFDekMscUVBQXFFO1lBQ3JFLElBQUksQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLGFBQWEsRUFBRSxDQUFDO2dCQUMvQixNQUFNLEdBQUcsTUFBTSxDQUFDLE9BQU8sQ0FBQyxtQkFBbUIsRUFBRSxFQUFFLENBQUMsQ0FBQztZQUNuRCxDQUFDO2lCQUFNLENBQUM7Z0JBQ04saUNBQWlDO2dCQUNqQyxNQUFNLEdBQUcsTUFBTSxDQUFDLE9BQU8sQ0FBQyx5QkFBeUIsRUFBRSxFQUFFLENBQUMsQ0FBQztZQUN6RCxDQUFDO1FBQ0gsQ0FBQztRQUVELHdEQUF3RDtRQUN4RCxJQUFJLElBQUksQ0FBQyxNQUFNLENBQUMscUJBQXFCLEVBQUUsQ0FBQztZQUN0QyxtQ0FBbUM7WUFDbkMsTUFBTSxHQUFHLE1BQU0sQ0FBQyxPQUFPLENBQ3JCLGtGQUFrRixFQUNsRixDQUFDLEtBQUssRUFBRSxLQUFLLEVBQUUsUUFBUSxFQUFFLElBQUksRUFBRSxHQUFHLEVBQUUsRUFBRTtnQkFDcEMsdUVBQXVFO2dCQUN2RSxPQUFPLEdBQUcsS0FBSyxpQ0FBaUMsR0FBRyxFQUFFLENBQUM7WUFDeEQsQ0FBQyxDQUNGLENBQUM7WUFFRiw4QkFBOEI7WUFDOUIsTUFBTSxHQUFHLE1BQU0sQ0FBQyxPQUFPLENBQ3JCLG9DQUFvQyxFQUNwQyxDQUFDLEtBQUssRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLEdBQUcsRUFBRSxFQUFFO2dCQUMxQixPQUFPLEdBQUcsS0FBSyxpQ0FBaUMsR0FBRyxFQUFFLENBQUM7WUFDeEQsQ0FBQyxDQUNGLENBQUM7WUFFRiw0QkFBNEI7WUFDNUIsTUFBTSxHQUFHLE1BQU0sQ0FBQyxPQUFPLENBQ3JCLDZDQUE2QyxFQUM3QyxDQUFDLEtBQUssRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLEdBQUcsRUFBRSxFQUFFO2dCQUMxQixPQUFPLEdBQUcsS0FBSyxpQ0FBaUMsR0FBRyxFQUFFLENBQUM7WUFDeEQsQ0FBQyxDQUNGLENBQUM7WUFFRixzQkFBc0I7WUFDdEIsTUFBTSxHQUFHLE1BQU0sQ0FBQyxPQUFPLENBQ3JCLHFGQUFxRixFQUNyRixDQUFDLEtBQUssRUFBRSxLQUFLLEVBQUUsUUFBUSxFQUFFLElBQUksRUFBRSxHQUFHLEVBQUUsRUFBRTtnQkFDcEMsT0FBTyxHQUFHLEtBQUssaUNBQWlDLEdBQUcsRUFBRSxDQUFDO1lBQ3hELENBQUMsQ0FDRixDQUFDO1FBQ0osQ0FBQzthQUFNLElBQUksSUFBSSxDQUFDLE1BQU0sQ0FBQyxnQkFBZ0IsSUFBSSxJQUFJLENBQUMsTUFBTSxDQUFDLGdCQUFnQixHQUFHLENBQUMsRUFBRSxDQUFDO1lBQzVFLHdFQUF3RTtZQUN4RSxtQ0FBbUM7WUFDbkMsTUFBTSxHQUFHLE1BQU0sQ0FBQyxPQUFPLENBQ3JCLGtGQUFrRixFQUNsRixDQUFDLEtBQUssRUFBRSxLQUFLLEVBQUUsUUFBUSxFQUFFLElBQUksRUFBRSxHQUFHLEVBQUUsRUFBRTtnQkFDcEMsT0FBTyxJQUFJLENBQUMsaUJBQWlCLENBQUMsS0FBSyxFQUFFLElBQUksRUFBRSxHQUFHLENBQUMsQ0FBQztZQUNsRCxDQUFDLENBQ0YsQ0FBQztZQUVGLDhCQUE4QjtZQUM5QixNQUFNLEdBQUcsTUFBTSxDQUFDLE9BQU8sQ0FDckIsb0NBQW9DLEVBQ3BDLENBQUMsS0FBSyxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUUsR0FBRyxFQUFFLEVBQUU7Z0JBQzFCLE9BQU8sSUFBSSxDQUFDLGlCQUFpQixDQUFDLEtBQUssRUFBRSxJQUFJLEVBQUUsR0FBRyxDQUFDLENBQUM7WUFDbEQsQ0FBQyxDQUNGLENBQUM7WUFFRiw0QkFBNEI7WUFDNUIsTUFBTSxHQUFHLE1BQU0sQ0FBQyxPQUFPLENBQ3JCLDZDQUE2QyxFQUM3QyxDQUFDLEtBQUssRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLEdBQUcsRUFBRSxFQUFFO2dCQUMxQixPQUFPLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxLQUFLLEVBQUUsSUFBSSxFQUFFLEdBQUcsQ0FBQyxDQUFDO1lBQ2xELENBQUMsQ0FDRixDQUFDO1lBRUYsc0JBQXNCO1lBQ3RCLE1BQU0sR0FBRyxNQUFNLENBQUMsT0FBTyxDQUNyQixxRkFBcUYsRUFDckYsQ0FBQyxLQUFLLEVBQUUsS0FBSyxFQUFFLFFBQVEsRUFBRSxJQUFJLEVBQUUsR0FBRyxFQUFFLEVBQUU7Z0JBQ3BDLE9BQU8sSUFBSSxDQUFDLGlCQUFpQixDQUFDLEtBQUssRUFBRSxJQUFJLEVBQUUsR0FBRyxDQUFDLENBQUM7WUFDbEQsQ0FBQyxDQUNGLENBQUM7UUFDSixDQUFDO1FBRUQsMkNBQTJDO1FBQzNDLElBQUksSUFBSSxDQUFDLE1BQU0sQ0FBQyxnQkFBZ0IsRUFBRSxDQUFDO1lBQ2pDLE1BQU0sR0FBRyxNQUFNLENBQUMsT0FBTyxDQUFDLGNBQWMsRUFBRSxFQUFFLENBQUMsQ0FBQztRQUM5QyxDQUFDO1FBRUQsMkNBQTJDO1FBQzNDLElBQUksSUFBSSxDQUFDLE1BQU0sQ0FBQyxhQUFhLElBQUksYUFBYSxDQUFDLE1BQU0sR0FBRyxDQUFDLEVBQUUsQ0FBQztZQUMxRCxnRkFBZ0Y7UUFDbEYsQ0FBQztRQUVELE9BQU8sTUFBTSxDQUFDO0lBQ2hCLENBQUM7SUFFRDs7Ozs7O09BTUc7SUFDSyxpQkFBaUIsQ0FBQyxLQUFhLEVBQUUsSUFBWSxFQUFFLEdBQVc7UUFDaEUsTUFBTSxLQUFLLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUMvQixJQUFJLEtBQUssQ0FBQyxNQUFNLEdBQUcsSUFBSSxDQUFDLE1BQU0sQ0FBQyxnQkFBaUIsRUFBRSxDQUFDO1lBQ2pELE1BQU0sV0FBVyxHQUFHLEtBQUssQ0FBQyxLQUFLLENBQUMsQ0FBQyxFQUFFLElBQUksQ0FBQyxNQUFNLENBQUMsZ0JBQWlCLENBQUMsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7WUFDN0UsT0FBTyxHQUFHLEtBQUssR0FBRyxXQUFXLGVBQWUsS0FBSyxDQUFDLE1BQU0sR0FBRyxJQUFJLENBQUMsTUFBTSxDQUFDLGdCQUFpQixvQkFBb0IsR0FBRyxFQUFFLENBQUM7UUFDcEgsQ0FBQztRQUNELE9BQU8sR0FBRyxLQUFLLEdBQUcsSUFBSSxHQUFHLEdBQUcsRUFBRSxDQUFDO0lBQ2pDLENBQUM7SUFFRDs7OztPQUlHO0lBQ0ssZ0JBQWdCLENBQUMsT0FBZTtRQUN0Qyw2REFBNkQ7UUFDN0Qsa0RBQWtEO1FBQ2xELE9BQU8sT0FBTyxDQUFDO0lBQ2pCLENBQUM7SUFFRDs7OztPQUlHO0lBQ0ssWUFBWSxDQUFDLE9BQWU7UUFDbEMsSUFBSSxDQUFDO1lBQ0gsaUJBQWlCO1lBQ2pCLE1BQU0sSUFBSSxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUM7WUFFakMsb0RBQW9EO1lBQ3BELElBQUksTUFBTSxJQUFJLElBQUksSUFBSSxTQUFTLElBQUksSUFBSSxJQUFJLGNBQWMsSUFBSSxJQUFJLEVBQUUsQ0FBQztnQkFDbEUsTUFBTSxhQUFhLEdBQUc7b0JBQ3BCLE1BQU0sRUFBRSxTQUFTLEVBQUUsYUFBYSxFQUFFLFFBQVEsRUFBRSxTQUFTO29CQUNyRCxNQUFNLEVBQUUsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNO2lCQUNuQyxDQUFDO2dCQUVGLE1BQU0sV0FBVyxHQUFRLEVBQUUsQ0FBQztnQkFDNUIsYUFBYSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsRUFBRTtvQkFDMUIsSUFBSSxHQUFHLElBQUksSUFBSSxFQUFFLENBQUM7d0JBQ2hCLFdBQVcsQ0FBQyxHQUFHLENBQUMsR0FBRyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7b0JBQy9CLENBQUM7Z0JBQ0gsQ0FBQyxDQUFDLENBQUM7Z0JBRUgsOENBQThDO2dCQUM5QyxJQUFJLGNBQWMsSUFBSSxJQUFJLEVBQUUsQ0FBQztvQkFDM0IsV0FBVyxDQUFDLFlBQVksR0FBRyxNQUFNLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxZQUFZLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxHQUFHLEVBQUUsR0FBRyxFQUFFLEVBQUU7d0JBQzVFLEdBQUcsQ0FBQyxHQUFHLENBQUMsR0FBRyxHQUFHLENBQUMsQ0FBQyxnQ0FBZ0M7d0JBQ2hELE9BQU8sR0FBRyxDQUFDO29CQUNiLENBQUMsRUFBRSxFQUE0QixDQUFDLENBQUM7Z0JBQ25DLENBQUM7Z0JBRUQsMEJBQTBCO2dCQUMxQixPQUFPLElBQUksQ0FBQyxTQUFTLENBQUMsV0FBVyxFQUFFLElBQUksRUFBRSxDQUFDLENBQUMsQ0FBQztZQUM5QyxDQUFDO1lBRUQsb0NBQW9DO1lBQ3BDLE9BQU8sT0FBTyxDQUFDO1FBQ2pCLENBQUM7UUFBQyxPQUFPLEtBQUssRUFBRSxDQUFDO1lBQ2Ysb0VBQW9FO1lBQ3BFLE9BQU8sT0FBTyxDQUFDO1FBQ2pCLENBQUM7SUFDSCxDQUFDO0lBRUQ7OztPQUdHO0lBQ0ksWUFBWSxDQUFDLE1BQW1CO1FBQ3JDLElBQUksQ0FBQyxNQUFNLEdBQUc7WUFDWixHQUFHLElBQUksQ0FBQyxNQUFNO1lBQ2QsR0FBRyxNQUFNO1NBQ1YsQ0FBQztJQUNKLENBQUM7Q0FDRiJ9

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

@@ -0,0 +1,75 @@
+import * as plugins from '../plugins.js';
+import type { ContextMode, IContextResult, TaskType } from './types.js';
+/**
+ * Enhanced ProjectContext that supports context optimization strategies
+ */
+export declare class EnhancedContext {
+    private projectDir;
+    private trimmer;
+    private configManager;
+    private contextMode;
+    private tokenBudget;
+    private contextResult;
+    /**
+     * Create a new EnhancedContext
+     * @param projectDirArg The project directory
+     */
+    constructor(projectDirArg: string);
+    /**
+     * Initialize the context builder
+     */
+    initialize(): Promise<void>;
+    /**
+     * Set the context mode
+     * @param mode The context mode to use
+     */
+    setContextMode(mode: ContextMode): void;
+    /**
+     * Set the token budget
+     * @param maxTokens The maximum tokens to use
+     */
+    setTokenBudget(maxTokens: number): void;
+    /**
+     * Gather files from the project
+     * @param includePaths Optional paths to include
+     * @param excludePaths Optional paths to exclude
+     */
+    gatherFiles(includePaths?: string[], excludePaths?: string[]): Promise<Record<string, plugins.smartfile.SmartFile | plugins.smartfile.SmartFile[]>>;
+    /**
+     * 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
+     */
+    buildContext(taskType?: TaskType): Promise<IContextResult>;
+    /**
+     * Update the context with git diff information for commit tasks
+     * @param gitDiff The git diff to include
+     */
+    updateWithGitDiff(gitDiff: string): IContextResult;
+    /**
+     * Count tokens in a string
+     * @param text The text to count tokens for
+     * @param model The model to use for token counting
+     */
+    countTokens(text: string, model?: string): number;
+    /**
+     * Get the context result
+     */
+    getContextResult(): IContextResult;
+    /**
+     * Get the token count for the current context
+     */
+    getTokenCount(): number;
+    /**
+     * Get both the context string and its token count
+     */
+    getContextWithTokenCount(): {
+        context: string;
+        tokenCount: number;
+    };
+}