@git.zone/tsdoc 1.4.5 → 1.5.1

package/dist_ts/context/enhanced-context.js

@@ -0,0 +1,272 @@
+import * as plugins from '../plugins.js';
+import { ContextTrimmer } from './context-trimmer.js';
+import { ConfigManager } from './config-manager.js';
+/**
+ * Enhanced ProjectContext that supports context optimization strategies
+ */
+export class EnhancedContext {
+    /**
+     * Create a new EnhancedContext
+     * @param projectDirArg The project directory
+     */
+    constructor(projectDirArg) {
+        this.contextMode = 'trimmed';
+        this.tokenBudget = 190000; // Default for o4-mini
+        this.contextResult = {
+            context: '',
+            tokenCount: 0,
+            includedFiles: [],
+            trimmedFiles: [],
+            excludedFiles: [],
+            tokenSavings: 0
+        };
+        this.projectDir = projectDirArg;
+        this.configManager = ConfigManager.getInstance();
+        this.trimmer = new ContextTrimmer(this.configManager.getTrimConfig());
+    }
+    /**
+     * Initialize the context builder
+     */
+    async initialize() {
+        await this.configManager.initialize(this.projectDir);
+        this.tokenBudget = this.configManager.getMaxTokens();
+        this.trimmer.updateConfig(this.configManager.getTrimConfig());
+    }
+    /**
+     * Set the context mode
+     * @param mode The context mode to use
+     */
+    setContextMode(mode) {
+        this.contextMode = mode;
+    }
+    /**
+     * Set the token budget
+     * @param maxTokens The maximum tokens to use
+     */
+    setTokenBudget(maxTokens) {
+        this.tokenBudget = maxTokens;
+    }
+    /**
+     * Gather files from the project
+     * @param includePaths Optional paths to include
+     * @param excludePaths Optional paths to exclude
+     */
+    async gatherFiles(includePaths, excludePaths) {
+        const smartfilePackageJSON = await plugins.smartfile.SmartFile.fromFilePath(plugins.path.join(this.projectDir, 'package.json'), this.projectDir);
+        const smartfilesReadme = await plugins.smartfile.SmartFile.fromFilePath(plugins.path.join(this.projectDir, 'readme.md'), this.projectDir);
+        const smartfilesReadmeHints = await plugins.smartfile.SmartFile.fromFilePath(plugins.path.join(this.projectDir, 'readme.hints.md'), this.projectDir);
+        const smartfilesNpmextraJSON = await plugins.smartfile.SmartFile.fromFilePath(plugins.path.join(this.projectDir, 'npmextra.json'), this.projectDir);
+        // Use provided include paths or default to all TypeScript files
+        const includeGlobs = includePaths?.map(path => `${path}/**/*.ts`) || ['ts*/**/*.ts'];
+        // Get TypeScript files
+        const smartfilesModPromises = includeGlobs.map(glob => plugins.smartfile.fs.fileTreeToObject(this.projectDir, glob));
+        const smartfilesModArrays = await Promise.all(smartfilesModPromises);
+        // Flatten the arrays
+        const smartfilesMod = [];
+        smartfilesModArrays.forEach(array => {
+            smartfilesMod.push(...array);
+        });
+        // Get test files if not excluded
+        let smartfilesTest = [];
+        if (!excludePaths?.includes('test/')) {
+            smartfilesTest = await plugins.smartfile.fs.fileTreeToObject(this.projectDir, 'test/**/*.ts');
+        }
+        return {
+            smartfilePackageJSON,
+            smartfilesReadme,
+            smartfilesReadmeHints,
+            smartfilesNpmextraJSON,
+            smartfilesMod,
+            smartfilesTest,
+        };
+    }
+    /**
+     * Convert files to context string
+     * @param files The files to convert
+     * @param mode The context mode to use
+     */
+    async convertFilesToContext(files, mode = this.contextMode) {
+        // Reset context result
+        this.contextResult = {
+            context: '',
+            tokenCount: 0,
+            includedFiles: [],
+            trimmedFiles: [],
+            excludedFiles: [],
+            tokenSavings: 0
+        };
+        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));
+        const processedFiles = [];
+        for (const smartfile of sortedFiles) {
+            // Calculate original token count
+            const originalContent = smartfile.contents.toString();
+            const originalTokenCount = this.countTokens(originalContent);
+            totalOriginalTokens += originalTokenCount;
+            // Apply trimming based on mode
+            let processedContent = originalContent;
+            if (mode !== 'full') {
+                processedContent = this.trimmer.trimFile(smartfile.relative, originalContent, mode);
+            }
+            // Calculate new token count
+            const processedTokenCount = this.countTokens(processedContent);
+            // Check if we have budget for this file
+            if (totalTokenCount + processedTokenCount > this.tokenBudget) {
+                // We don't have budget for this file
+                this.contextResult.excludedFiles.push({
+                    path: smartfile.path,
+                    contents: originalContent,
+                    relativePath: smartfile.relative,
+                    tokenCount: originalTokenCount
+                });
+                continue;
+            }
+            // Format the file for context
+            const formattedContent = `
+====== START OF FILE ${smartfile.relative} ======
+  
+${processedContent}
+  
+====== END OF FILE ${smartfile.relative} ======
+      `;
+            processedFiles.push(formattedContent);
+            totalTokenCount += processedTokenCount;
+            // Track file in appropriate list
+            const fileInfo = {
+                path: smartfile.path,
+                contents: processedContent,
+                relativePath: smartfile.relative,
+                tokenCount: processedTokenCount
+            };
+            if (mode === 'full' || processedContent === originalContent) {
+                this.contextResult.includedFiles.push(fileInfo);
+            }
+            else {
+                this.contextResult.trimmedFiles.push(fileInfo);
+                this.contextResult.tokenSavings += (originalTokenCount - processedTokenCount);
+            }
+        }
+        // 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
+     */
+    async buildContext(taskType) {
+        // Initialize if needed
+        if (this.tokenBudget === 0) {
+            await this.initialize();
+        }
+        // Get task-specific configuration if a task type is provided
+        if (taskType) {
+            const taskConfig = this.configManager.getTaskConfig(taskType);
+            if (taskConfig.mode) {
+                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);
+            }
+        }
+        if (files.smartfilesTest) {
+            if (Array.isArray(files.smartfilesTest)) {
+                allFiles.push(...files.smartfilesTest);
+            }
+            else {
+                allFiles.push(files.smartfilesTest);
+            }
+        }
+        const context = await this.convertFilesToContext(allFiles);
+        return this.contextResult;
+    }
+    /**
+     * Update the context with git diff information for commit tasks
+     * @param gitDiff The git diff to include
+     */
+    updateWithGitDiff(gitDiff) {
+        // If we don't have a context yet, return empty result
+        if (!this.contextResult.context) {
+            return this.contextResult;
+        }
+        // Add git diff to context
+        const diffSection = `
+====== GIT DIFF ======
+
+${gitDiff}
+
+====== END GIT DIFF ======
+    `;
+        const diffTokenCount = this.countTokens(diffSection);
+        // Update context and token count
+        this.contextResult.context += diffSection;
+        this.contextResult.tokenCount += diffTokenCount;
+        return this.contextResult;
+    }
+    /**
+     * Count tokens in a string
+     * @param text The text to count tokens for
+     * @param model The model to use for token counting
+     */
+    countTokens(text, model = 'gpt-3.5-turbo') {
+        try {
+            // Use the gpt-tokenizer library to count tokens
+            const tokens = plugins.gptTokenizer.encode(text);
+            return tokens.length;
+        }
+        catch (error) {
+            console.error('Error counting tokens:', error);
+            // Provide a rough estimate if tokenization fails
+            return Math.ceil(text.length / 4);
+        }
+    }
+    /**
+     * Get the context result
+     */
+    getContextResult() {
+        return this.contextResult;
+    }
+    /**
+     * Get the token count for the current context
+     */
+    getTokenCount() {
+        return this.contextResult.tokenCount;
+    }
+    /**
+     * Get both the context string and its token count
+     */
+    getContextWithTokenCount() {
+        return {
+            context: this.contextResult.context,
+            tokenCount: this.contextResult.tokenCount
+        };
+    }
+}
+//# 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

@@ -0,0 +1,7 @@
+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 };

package/dist_ts/context/index.js

@@ -0,0 +1,8 @@
+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';
+export { 
+// Classes
+EnhancedContext, TaskContextFactory, ConfigManager, ContextTrimmer, };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9jb250ZXh0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUN4RCxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUMvRCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDcEQsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBV3RELE9BQU87QUFDTCxVQUFVO0FBQ1YsZUFBZSxFQUNmLGtCQUFrQixFQUNsQixhQUFhLEVBQ2IsY0FBYyxHQUNmLENBQUMifQ==

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

@@ -0,0 +1,46 @@
+import type { IContextResult, TaskType } from './types.js';
+/**
+ * Factory class for creating task-specific context
+ */
+export declare class TaskContextFactory {
+    private projectDir;
+    private configManager;
+    /**
+     * Create a new TaskContextFactory
+     * @param projectDirArg The project directory
+     */
+    constructor(projectDirArg: string);
+    /**
+     * Initialize the factory
+     */
+    initialize(): Promise<void>;
+    /**
+     * Create context for README generation
+     */
+    createContextForReadme(): Promise<IContextResult>;
+    /**
+     * Create context for description generation
+     */
+    createContextForDescription(): Promise<IContextResult>;
+    /**
+     * Create context for commit message generation
+     * @param gitDiff Optional git diff to include
+     */
+    createContextForCommit(gitDiff?: string): Promise<IContextResult>;
+    /**
+     * Create context for any task type
+     * @param taskType The task type to create context for
+     * @param additionalContent Optional additional content to include
+     */
+    createContextForTask(taskType: TaskType, additionalContent?: string): Promise<IContextResult>;
+    /**
+     * Get token stats for all task types
+     */
+    getTokenStats(): Promise<Record<TaskType, {
+        tokenCount: number;
+        savings: number;
+        includedFiles: number;
+        trimmedFiles: number;
+        excludedFiles: number;
+    }>>;
+}

package/dist_ts/context/task-context-factory.js

@@ -0,0 +1,109 @@
+import * as plugins from '../plugins.js';
+import { EnhancedContext } from './enhanced-context.js';
+import { ConfigManager } from './config-manager.js';
+/**
+ * Factory class for creating task-specific context
+ */
+export class TaskContextFactory {
+    /**
+     * Create a new TaskContextFactory
+     * @param projectDirArg The project directory
+     */
+    constructor(projectDirArg) {
+        this.projectDir = projectDirArg;
+        this.configManager = ConfigManager.getInstance();
+    }
+    /**
+     * Initialize the factory
+     */
+    async initialize() {
+        await this.configManager.initialize(this.projectDir);
+    }
+    /**
+     * Create context for README generation
+     */
+    async createContextForReadme() {
+        const contextBuilder = new EnhancedContext(this.projectDir);
+        await contextBuilder.initialize();
+        // Get README-specific configuration
+        const taskConfig = this.configManager.getTaskConfig('readme');
+        if (taskConfig.mode) {
+            contextBuilder.setContextMode(taskConfig.mode);
+        }
+        // Build the context for README task
+        return await contextBuilder.buildContext('readme');
+    }
+    /**
+     * Create context for description generation
+     */
+    async createContextForDescription() {
+        const contextBuilder = new EnhancedContext(this.projectDir);
+        await contextBuilder.initialize();
+        // Get description-specific configuration
+        const taskConfig = this.configManager.getTaskConfig('description');
+        if (taskConfig.mode) {
+            contextBuilder.setContextMode(taskConfig.mode);
+        }
+        // Build the context for description task
+        return await contextBuilder.buildContext('description');
+    }
+    /**
+     * Create context for commit message generation
+     * @param gitDiff Optional git diff to include
+     */
+    async createContextForCommit(gitDiff) {
+        const contextBuilder = new EnhancedContext(this.projectDir);
+        await contextBuilder.initialize();
+        // Get commit-specific configuration
+        const taskConfig = this.configManager.getTaskConfig('commit');
+        if (taskConfig.mode) {
+            contextBuilder.setContextMode(taskConfig.mode);
+        }
+        // Build the context for commit task
+        const contextResult = await contextBuilder.buildContext('commit');
+        // If git diff is provided, add it to the context
+        if (gitDiff) {
+            contextBuilder.updateWithGitDiff(gitDiff);
+        }
+        return contextBuilder.getContextResult();
+    }
+    /**
+     * Create context for any task type
+     * @param taskType The task type to create context for
+     * @param additionalContent Optional additional content to include
+     */
+    async createContextForTask(taskType, additionalContent) {
+        switch (taskType) {
+            case 'readme':
+                return this.createContextForReadme();
+            case 'description':
+                return this.createContextForDescription();
+            case 'commit':
+                return this.createContextForCommit(additionalContent);
+            default:
+                // Generic context for unknown task types
+                const contextBuilder = new EnhancedContext(this.projectDir);
+                await contextBuilder.initialize();
+                return await contextBuilder.buildContext();
+        }
+    }
+    /**
+     * Get token stats for all task types
+     */
+    async getTokenStats() {
+        const taskTypes = ['readme', 'description', 'commit'];
+        const stats = {};
+        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;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFzay1jb250ZXh0LWZhY3RvcnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9jb250ZXh0L3Rhc2stY29udGV4dC1mYWN0b3J5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUN4RCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFHcEQ7O0dBRUc7QUFDSCxNQUFNLE9BQU8sa0JBQWtCO0lBSTdCOzs7T0FHRztJQUNILFlBQVksYUFBcUI7UUFDL0IsSUFBSSxDQUFDLFVBQVUsR0FBRyxhQUFhLENBQUM7UUFDaEMsSUFBSSxDQUFDLGFBQWEsR0FBRyxhQUFhLENBQUMsV0FBVyxFQUFFLENBQUM7SUFDbkQsQ0FBQztJQUVEOztPQUVHO0lBQ0ksS0FBSyxDQUFDLFVBQVU7UUFDckIsTUFBTSxJQUFJLENBQUMsYUFBYSxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLENBQUM7SUFDdkQsQ0FBQztJQUVEOztPQUVHO0lBQ0ksS0FBSyxDQUFDLHNCQUFzQjtRQUNqQyxNQUFNLGNBQWMsR0FBRyxJQUFJLGVBQWUsQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLENBQUM7UUFDNUQsTUFBTSxjQUFjLENBQUMsVUFBVSxFQUFFLENBQUM7UUFFbEMsb0NBQW9DO1FBQ3BDLE1BQU0sVUFBVSxHQUFHLElBQUksQ0FBQyxhQUFhLENBQUMsYUFBYSxDQUFDLFFBQVEsQ0FBQyxDQUFDO1FBQzlELElBQUksVUFBVSxDQUFDLElBQUksRUFBRSxDQUFDO1lBQ3BCLGNBQWMsQ0FBQyxjQUFjLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ2pELENBQUM7UUFFRCxvQ0FBb0M7UUFDcEMsT0FBTyxNQUFNLGNBQWMsQ0FBQyxZQUFZLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDckQsQ0FBQztJQUVEOztPQUVHO0lBQ0ksS0FBSyxDQUFDLDJCQUEyQjtRQUN0QyxNQUFNLGNBQWMsR0FBRyxJQUFJLGVBQWUsQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLENBQUM7UUFDNUQsTUFBTSxjQUFjLENBQUMsVUFBVSxFQUFFLENBQUM7UUFFbEMseUNBQXlDO1FBQ3pDLE1BQU0sVUFBVSxHQUFHLElBQUksQ0FBQyxhQUFhLENBQUMsYUFBYSxDQUFDLGFBQWEsQ0FBQyxDQUFDO1FBQ25FLElBQUksVUFBVSxDQUFDLElBQUksRUFBRSxDQUFDO1lBQ3BCLGNBQWMsQ0FBQyxjQUFjLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ2pELENBQUM7UUFFRCx5Q0FBeUM7UUFDekMsT0FBTyxNQUFNLGNBQWMsQ0FBQyxZQUFZLENBQUMsYUFBYSxDQUFDLENBQUM7SUFDMUQsQ0FBQztJQUVEOzs7T0FHRztJQUNJLEtBQUssQ0FBQyxzQkFBc0IsQ0FBQyxPQUFnQjtRQUNsRCxNQUFNLGNBQWMsR0FBRyxJQUFJLGVBQWUsQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLENBQUM7UUFDNUQsTUFBTSxjQUFjLENBQUMsVUFBVSxFQUFFLENBQUM7UUFFbEMsb0NBQW9DO1FBQ3BDLE1BQU0sVUFBVSxHQUFHLElBQUksQ0FBQyxhQUFhLENBQUMsYUFBYSxDQUFDLFFBQVEsQ0FBQyxDQUFDO1FBQzlELElBQUksVUFBVSxDQUFDLElBQUksRUFBRSxDQUFDO1lBQ3BCLGNBQWMsQ0FBQyxjQUFjLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ2pELENBQUM7UUFFRCxvQ0FBb0M7UUFDcEMsTUFBTSxhQUFhLEdBQUcsTUFBTSxjQUFjLENBQUMsWUFBWSxDQUFDLFFBQVEsQ0FBQyxDQUFDO1FBRWxFLGlEQUFpRDtRQUNqRCxJQUFJLE9BQU8sRUFBRSxDQUFDO1lBQ1osY0FBYyxDQUFDLGlCQUFpQixDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQzVDLENBQUM7UUFFRCxPQUFPLGNBQWMsQ0FBQyxnQkFBZ0IsRUFBRSxDQUFDO0lBQzNDLENBQUM7SUFFRDs7OztPQUlHO0lBQ0ksS0FBSyxDQUFDLG9CQUFvQixDQUMvQixRQUFrQixFQUNsQixpQkFBMEI7UUFFMUIsUUFBUSxRQUFRLEVBQUUsQ0FBQztZQUNqQixLQUFLLFFBQVE7Z0JBQ1gsT0FBTyxJQUFJLENBQUMsc0JBQXNCLEVBQUUsQ0FBQztZQUN2QyxLQUFLLGFBQWE7Z0JBQ2hCLE9BQU8sSUFBSSxDQUFDLDJCQUEyQixFQUFFLENBQUM7WUFDNUMsS0FBSyxRQUFRO2dCQUNYLE9BQU8sSUFBSSxDQUFDLHNCQUFzQixDQUFDLGlCQUFpQixDQUFDLENBQUM7WUFDeEQ7Z0JBQ0UseUNBQXlDO2dCQUN6QyxNQUFNLGNBQWMsR0FBRyxJQUFJLGVBQWUsQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLENBQUM7Z0JBQzVELE1BQU0sY0FBYyxDQUFDLFVBQVUsRUFBRSxDQUFDO2dCQUNsQyxPQUFPLE1BQU0sY0FBYyxDQUFDLFlBQVksRUFBRSxDQUFDO1FBQy9DLENBQUM7SUFDSCxDQUFDO0lBRUQ7O09BRUc7SUFDSSxLQUFLLENBQUMsYUFBYTtRQU94QixNQUFNLFNBQVMsR0FBZSxDQUFDLFFBQVEsRUFBRSxhQUFhLEVBQUUsUUFBUSxDQUFDLENBQUM7UUFDbEUsTUFBTSxLQUFLLEdBQTBCLEVBQVMsQ0FBQztRQUUvQyxLQUFLLE1BQU0sUUFBUSxJQUFJLFNBQVMsRUFBRSxDQUFDO1lBQ2pDLE1BQU0sTUFBTSxHQUFHLE1BQU0sSUFBSSxDQUFDLG9CQUFvQixDQUFDLFFBQVEsQ0FBQyxDQUFDO1lBQ3pELEtBQUssQ0FBQyxRQUFRLENBQUMsR0FBRztnQkFDaEIsVUFBVSxFQUFFLE1BQU0sQ0FBQyxVQUFVO2dCQUM3QixPQUFPLEVBQUUsTUFBTSxDQUFDLFlBQVk7Z0JBQzVCLGFBQWEsRUFBRSxNQUFNLENBQUMsYUFBYSxDQUFDLE1BQU07Z0JBQzFDLFlBQVksRUFBRSxNQUFNLENBQUMsWUFBWSxDQUFDLE1BQU07Z0JBQ3hDLGFBQWEsRUFBRSxNQUFNLENBQUMsYUFBYSxDQUFDLE1BQU07YUFDM0MsQ0FBQztRQUNKLENBQUM7UUFFRCxPQUFPLEtBQUssQ0FBQztJQUNmLENBQUM7Q0FDRiJ9

package/dist_ts/context/types.d.ts

@@ -0,0 +1,89 @@
+/**
+ * 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;
+}
+/**
+ * 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;
+}

package/dist_ts/context/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9jb250ZXh0L3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/dist_ts/plugins.d.ts

@@ -17,4 +17,5 @@ export { npmextra, qenv, smartai, smartcli, smartdelay, smartfile, smartgit, sma
 import * as tspublish from '@git.zone/tspublish';
 export { tspublish };
 import * as typedoc from 'typedoc';
-export { typedoc };
+import * as gptTokenizer from 'gpt-tokenizer';
+export { typedoc, gptTokenizer };

package/dist_ts/plugins.js

@@ -21,5 +21,6 @@ import * as tspublish from '@git.zone/tspublish';
 export { tspublish };
 // third party scope
 import * as typedoc from 'typedoc';
-export { typedoc };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYztBQUNkLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBRTdCLE9BQU8sRUFBRSxJQUFJLEVBQUUsQ0FBQztBQUVoQixrQkFBa0I7QUFDbEIsT0FBTyxLQUFLLFFBQVEsTUFBTSxzQkFBc0IsQ0FBQztBQUNqRCxPQUFPLEtBQUssSUFBSSxNQUFNLGtCQUFrQixDQUFDO0FBQ3pDLE9BQU8sS0FBSyxPQUFPLE1BQU0scUJBQXFCLENBQUM7QUFDL0MsT0FBTyxLQUFLLFFBQVEsTUFBTSxzQkFBc0IsQ0FBQztBQUNqRCxPQUFPLEtBQUssVUFBVSxNQUFNLHdCQUF3QixDQUFDO0FBQ3JELE9BQU8sS0FBSyxTQUFTLE1BQU0sdUJBQXVCLENBQUM7QUFDbkQsT0FBTyxLQUFLLFFBQVEsTUFBTSxzQkFBc0IsQ0FBQztBQUNqRCxPQUFPLEtBQUssYUFBYSxNQUFNLDJCQUEyQixDQUFDO0FBQzNELE9BQU8sS0FBSyxRQUFRLE1BQU0sc0JBQXNCLENBQUM7QUFDakQsT0FBTyxLQUFLLHdCQUF3QixNQUFNLHdDQUF3QyxDQUFDO0FBQ25GLE9BQU8sS0FBSyxTQUFTLE1BQU0sdUJBQXVCLENBQUM7QUFDbkQsT0FBTyxLQUFLLFVBQVUsTUFBTSx3QkFBd0IsQ0FBQztBQUNyRCxPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBRW5ELE9BQU8sRUFDTCxRQUFRLEVBQ1IsSUFBSSxFQUNKLE9BQU8sRUFDUCxRQUFRLEVBQ1IsVUFBVSxFQUNWLFNBQVMsRUFDVCxRQUFRLEVBQ1IsYUFBYSxFQUNiLFFBQVEsRUFDUix3QkFBd0IsRUFDeEIsU0FBUyxFQUNULFVBQVUsRUFDVixTQUFTLEdBQ1YsQ0FBQztBQUVGLGtCQUFrQjtBQUNsQixPQUFPLEtBQUssU0FBUyxNQUFNLHFCQUFxQixDQUFDO0FBRWpELE9BQU8sRUFBRSxTQUFTLEVBQUUsQ0FBQztBQUVyQixvQkFBb0I7QUFDcEIsT0FBTyxLQUFLLE9BQU8sTUFBTSxTQUFTLENBQUM7QUFFbkMsT0FBTyxFQUFFLE9BQU8sRUFBRSxDQUFDIn0=
+import * as gptTokenizer from 'gpt-tokenizer';
+export { typedoc, gptTokenizer };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYztBQUNkLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBRTdCLE9BQU8sRUFBRSxJQUFJLEVBQUUsQ0FBQztBQUVoQixrQkFBa0I7QUFDbEIsT0FBTyxLQUFLLFFBQVEsTUFBTSxzQkFBc0IsQ0FBQztBQUNqRCxPQUFPLEtBQUssSUFBSSxNQUFNLGtCQUFrQixDQUFDO0FBQ3pDLE9BQU8sS0FBSyxPQUFPLE1BQU0scUJBQXFCLENBQUM7QUFDL0MsT0FBTyxLQUFLLFFBQVEsTUFBTSxzQkFBc0IsQ0FBQztBQUNqRCxPQUFPLEtBQUssVUFBVSxNQUFNLHdCQUF3QixDQUFDO0FBQ3JELE9BQU8sS0FBSyxTQUFTLE1BQU0sdUJBQXVCLENBQUM7QUFDbkQsT0FBTyxLQUFLLFFBQVEsTUFBTSxzQkFBc0IsQ0FBQztBQUNqRCxPQUFPLEtBQUssYUFBYSxNQUFNLDJCQUEyQixDQUFDO0FBQzNELE9BQU8sS0FBSyxRQUFRLE1BQU0sc0JBQXNCLENBQUM7QUFDakQsT0FBTyxLQUFLLHdCQUF3QixNQUFNLHdDQUF3QyxDQUFDO0FBQ25GLE9BQU8sS0FBSyxTQUFTLE1BQU0sdUJBQXVCLENBQUM7QUFDbkQsT0FBTyxLQUFLLFVBQVUsTUFBTSx3QkFBd0IsQ0FBQztBQUNyRCxPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBRW5ELE9BQU8sRUFDTCxRQUFRLEVBQ1IsSUFBSSxFQUNKLE9BQU8sRUFDUCxRQUFRLEVBQ1IsVUFBVSxFQUNWLFNBQVMsRUFDVCxRQUFRLEVBQ1IsYUFBYSxFQUNiLFFBQVEsRUFDUix3QkFBd0IsRUFDeEIsU0FBUyxFQUNULFVBQVUsRUFDVixTQUFTLEdBQ1YsQ0FBQztBQUVGLGtCQUFrQjtBQUNsQixPQUFPLEtBQUssU0FBUyxNQUFNLHFCQUFxQixDQUFDO0FBRWpELE9BQU8sRUFBRSxTQUFTLEVBQUUsQ0FBQztBQUVyQixvQkFBb0I7QUFDcEIsT0FBTyxLQUFLLE9BQU8sTUFBTSxTQUFTLENBQUM7QUFDbkMsT0FBTyxLQUFLLFlBQVksTUFBTSxlQUFlLENBQUM7QUFFOUMsT0FBTyxFQUFFLE9BQU8sRUFBRSxZQUFZLEVBQUUsQ0FBQyJ9

package/npmextra.json

@@ -9,18 +9,19 @@
       "npmPackagename": "@git.zone/tsdoc",
       "license": "MIT",
       "projectDomain": "git.zone",
-      "description": "An advanced TypeScript documentation tool using AI to generate and enhance documentation for TypeScript projects.",
+      "description": "A comprehensive TypeScript documentation tool that leverages AI to generate and enhance project documentation, including dynamic README creation, API docs via TypeDoc, and smart commit message generation.",
       "keywords": [
         "TypeScript",
-        "documentation generation",
-        "AI-enhanced documentation",
-        "CLI tool",
+        "documentation",
+        "AI",
+        "CLI",
+        "README",
+        "TypeDoc",
+        "commit messages",
+        "automation",
         "code analysis",
-        "automated documentation",
-        "developer tools",
-        "API documentation",
-        "technical writing",
-        "code quality improvement"
+        "context trimming",
+        "developer tools"
       ]
     }
   },