@git.zone/tsdoc 1.6.0 → 1.7.0

package/dist_ts/context/index.js

@@ -8,4 +8,4 @@ import { ContextAnalyzer } from './context-analyzer.js';
 export { 
 // Classes
 EnhancedContext, TaskContextFactory, ConfigManager, ContextTrimmer, LazyFileLoader, ContextCache, ContextAnalyzer, };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9jb250ZXh0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUN4RCxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUMvRCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDcEQsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQ3RELE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUN2RCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDbEQsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBcUJ4RCxPQUFPO0FBQ0wsVUFBVTtBQUNWLGVBQWUsRUFDZixrQkFBa0IsRUFDbEIsYUFBYSxFQUNiLGNBQWMsRUFDZCxjQUFjLEVBQ2QsWUFBWSxFQUNaLGVBQWUsR0FDaEIsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9jb250ZXh0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUN4RCxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUMvRCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDcEQsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQ3RELE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUN2RCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDbEQsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBdUJ4RCxPQUFPO0FBQ0wsVUFBVTtBQUNWLGVBQWUsRUFDZixrQkFBa0IsRUFDbEIsYUFBYSxFQUNiLGNBQWMsRUFDZCxjQUFjLEVBQ2QsWUFBWSxFQUNaLGVBQWUsR0FDaEIsQ0FBQyJ9

package/dist_ts/context/iterative-context-builder.d.ts

@@ -0,0 +1,58 @@
+import type { TaskType, IIterativeContextResult, IIterativeConfig } from './types.js';
+/**
+ * Iterative context builder that uses AI to intelligently select files
+ * across multiple iterations until sufficient context is gathered
+ */
+export declare class IterativeContextBuilder {
+    private projectRoot;
+    private lazyLoader;
+    private cache;
+    private analyzer;
+    private config;
+    private tokenBudget;
+    private openaiInstance;
+    /**
+     * Creates a new IterativeContextBuilder
+     * @param projectRoot - Root directory of the project
+     * @param config - Iterative configuration
+     */
+    constructor(projectRoot: string, config?: Partial<IIterativeConfig>);
+    /**
+     * Initialize the builder
+     */
+    initialize(): Promise<void>;
+    /**
+     * Build context iteratively using AI decision making
+     * @param taskType - Type of task being performed
+     * @returns Complete iterative context result
+     */
+    buildContextIteratively(taskType: TaskType): Promise<IIterativeContextResult>;
+    /**
+     * Scan project files based on task type
+     */
+    private scanProjectFiles;
+    /**
+     * Get AI decision on which files to load
+     */
+    private getFileSelectionDecision;
+    /**
+     * Build prompt for file selection
+     */
+    private buildFileSelectionPrompt;
+    /**
+     * Evaluate if current context is sufficient
+     */
+    private evaluateContextSufficiency;
+    /**
+     * Load a single file with caching
+     */
+    private loadFile;
+    /**
+     * Format a file for inclusion in context
+     */
+    private formatFileForContext;
+    /**
+     * Count tokens in text
+     */
+    private countTokens;
+}

package/dist_ts/context/iterative-context-builder.js

@@ -0,0 +1,361 @@
+import * as plugins from '../plugins.js';
+import * as fs from 'fs';
+import { logger } from '../logging.js';
+import { LazyFileLoader } from './lazy-file-loader.js';
+import { ContextCache } from './context-cache.js';
+import { ContextAnalyzer } from './context-analyzer.js';
+import { ConfigManager } from './config-manager.js';
+/**
+ * Iterative context builder that uses AI to intelligently select files
+ * across multiple iterations until sufficient context is gathered
+ */
+export class IterativeContextBuilder {
+    /**
+     * Creates a new IterativeContextBuilder
+     * @param projectRoot - Root directory of the project
+     * @param config - Iterative configuration
+     */
+    constructor(projectRoot, config) {
+        this.tokenBudget = 190000;
+        this.projectRoot = projectRoot;
+        this.lazyLoader = new LazyFileLoader(projectRoot);
+        this.cache = new ContextCache(projectRoot);
+        this.analyzer = new ContextAnalyzer(projectRoot);
+        // Default configuration
+        this.config = {
+            maxIterations: config?.maxIterations ?? 5,
+            firstPassFileLimit: config?.firstPassFileLimit ?? 10,
+            subsequentPassFileLimit: config?.subsequentPassFileLimit ?? 5,
+            temperature: config?.temperature ?? 0.3,
+            model: config?.model ?? 'gpt-4-turbo-preview',
+        };
+    }
+    /**
+     * Initialize the builder
+     */
+    async initialize() {
+        await this.cache.init();
+        const configManager = ConfigManager.getInstance();
+        await configManager.initialize(this.projectRoot);
+        this.tokenBudget = configManager.getMaxTokens();
+        // Initialize OpenAI instance
+        const qenvInstance = new plugins.qenv.Qenv();
+        const openaiToken = await qenvInstance.getEnvVarOnDemand('OPENAI_TOKEN');
+        if (!openaiToken) {
+            throw new Error('OPENAI_TOKEN environment variable is required for iterative context building');
+        }
+        this.openaiInstance = new plugins.smartai.OpenAiProvider({
+            openaiToken,
+        });
+        await this.openaiInstance.start();
+    }
+    /**
+     * Build context iteratively using AI decision making
+     * @param taskType - Type of task being performed
+     * @returns Complete iterative context result
+     */
+    async buildContextIteratively(taskType) {
+        const startTime = Date.now();
+        logger.log('info', '🤖 Starting iterative context building...');
+        logger.log('info', `   Task: ${taskType}, Budget: ${this.tokenBudget} tokens, Max iterations: ${this.config.maxIterations}`);
+        // Phase 1: Scan project files for metadata
+        logger.log('info', '📋 Scanning project files...');
+        const metadata = await this.scanProjectFiles(taskType);
+        const totalEstimatedTokens = metadata.reduce((sum, m) => sum + m.estimatedTokens, 0);
+        logger.log('info', `   Found ${metadata.length} files (~${totalEstimatedTokens} estimated tokens)`);
+        // Phase 2: Analyze files for initial prioritization
+        logger.log('info', '🔍 Analyzing file dependencies and importance...');
+        const analysis = await this.analyzer.analyze(metadata, taskType, []);
+        logger.log('info', `   Analysis complete in ${analysis.analysisDuration}ms`);
+        // Track state across iterations
+        const iterations = [];
+        let totalTokensUsed = 0;
+        let apiCallCount = 0;
+        let loadedContent = '';
+        const includedFiles = [];
+        // Phase 3: Iterative file selection and loading
+        for (let iteration = 1; iteration <= this.config.maxIterations; iteration++) {
+            const iterationStart = Date.now();
+            logger.log('info', `\n🤔 Iteration ${iteration}/${this.config.maxIterations}: Asking AI which files to examine...`);
+            const remainingBudget = this.tokenBudget - totalTokensUsed;
+            logger.log('info', `   Token budget remaining: ${remainingBudget}/${this.tokenBudget} (${Math.round((remainingBudget / this.tokenBudget) * 100)}%)`);
+            // Get AI decision on which files to load
+            const decision = await this.getFileSelectionDecision(metadata, analysis.files.slice(0, 30), // Top 30 files by importance
+            taskType, iteration, totalTokensUsed, remainingBudget, loadedContent);
+            apiCallCount++;
+            logger.log('info', `   AI reasoning: ${decision.reasoning}`);
+            logger.log('info', `   AI requested ${decision.filesToLoad.length} files`);
+            // Load requested files
+            const iterationFiles = [];
+            let iterationTokens = 0;
+            if (decision.filesToLoad.length > 0) {
+                logger.log('info', '📥 Loading requested files...');
+                for (const filePath of decision.filesToLoad) {
+                    try {
+                        const fileInfo = await this.loadFile(filePath);
+                        if (totalTokensUsed + fileInfo.tokenCount <= this.tokenBudget) {
+                            const formattedFile = this.formatFileForContext(fileInfo);
+                            loadedContent += formattedFile;
+                            includedFiles.push(fileInfo);
+                            iterationFiles.push(fileInfo);
+                            iterationTokens += fileInfo.tokenCount;
+                            totalTokensUsed += fileInfo.tokenCount;
+                            logger.log('info', `   ✓ ${fileInfo.relativePath} (${fileInfo.tokenCount} tokens)`);
+                        }
+                        else {
+                            logger.log('warn', `   ✗ ${fileInfo.relativePath} - would exceed budget, skipping`);
+                        }
+                    }
+                    catch (error) {
+                        logger.log('warn', `   ✗ Failed to load ${filePath}: ${error.message}`);
+                    }
+                }
+            }
+            // Record iteration state
+            const iterationDuration = Date.now() - iterationStart;
+            iterations.push({
+                iteration,
+                filesLoaded: iterationFiles,
+                tokensUsed: iterationTokens,
+                totalTokensUsed,
+                decision,
+                duration: iterationDuration,
+            });
+            logger.log('info', `   Iteration ${iteration} complete: ${iterationFiles.length} files loaded, ${iterationTokens} tokens used`);
+            // Check if we should continue
+            if (totalTokensUsed >= this.tokenBudget * 0.95) {
+                logger.log('warn', '⚠️  Approaching token budget limit, stopping iterations');
+                break;
+            }
+            // Ask AI if context is sufficient
+            if (iteration < this.config.maxIterations) {
+                logger.log('info', '🤔 Asking AI if context is sufficient...');
+                const sufficiencyDecision = await this.evaluateContextSufficiency(loadedContent, taskType, iteration, totalTokensUsed, remainingBudget - iterationTokens);
+                apiCallCount++;
+                logger.log('info', `   AI decision: ${sufficiencyDecision.sufficient ? '✅ SUFFICIENT' : '⏭️  NEEDS MORE'}`);
+                logger.log('info', `   Reasoning: ${sufficiencyDecision.reasoning}`);
+                if (sufficiencyDecision.sufficient) {
+                    logger.log('ok', '✅ Context building complete - AI determined context is sufficient');
+                    break;
+                }
+            }
+        }
+        const totalDuration = Date.now() - startTime;
+        logger.log('ok', `\n✅ Iterative context building complete!`);
+        logger.log('info', `   Files included: ${includedFiles.length}`);
+        logger.log('info', `   Token usage: ${totalTokensUsed}/${this.tokenBudget} (${Math.round((totalTokensUsed / this.tokenBudget) * 100)}%)`);
+        logger.log('info', `   Iterations: ${iterations.length}, API calls: ${apiCallCount}`);
+        logger.log('info', `   Total duration: ${(totalDuration / 1000).toFixed(2)}s`);
+        return {
+            context: loadedContent,
+            tokenCount: totalTokensUsed,
+            includedFiles,
+            trimmedFiles: [],
+            excludedFiles: [],
+            tokenSavings: 0,
+            iterationCount: iterations.length,
+            iterations,
+            apiCallCount,
+            totalDuration,
+        };
+    }
+    /**
+     * Scan project files based on task type
+     */
+    async scanProjectFiles(taskType) {
+        const configManager = ConfigManager.getInstance();
+        const taskConfig = configManager.getTaskConfig(taskType);
+        const includeGlobs = taskConfig?.includePaths?.map(p => `${p}/**/*.ts`) || [
+            'ts/**/*.ts',
+            'ts*/**/*.ts'
+        ];
+        const configGlobs = [
+            'package.json',
+            'readme.md',
+            'readme.hints.md',
+            'npmextra.json'
+        ];
+        return await this.lazyLoader.scanFiles([...configGlobs, ...includeGlobs]);
+    }
+    /**
+     * Get AI decision on which files to load
+     */
+    async getFileSelectionDecision(allMetadata, analyzedFiles, taskType, iteration, tokensUsed, remainingBudget, loadedContent) {
+        const isFirstIteration = iteration === 1;
+        const fileLimit = isFirstIteration
+            ? this.config.firstPassFileLimit
+            : this.config.subsequentPassFileLimit;
+        const systemPrompt = this.buildFileSelectionPrompt(allMetadata, analyzedFiles, taskType, iteration, tokensUsed, remainingBudget, loadedContent, fileLimit);
+        const response = await this.openaiInstance.chat({
+            systemMessage: `You are an AI assistant that helps select the most relevant files for code analysis.
+You must respond ONLY with valid JSON that can be parsed with JSON.parse().
+Do not wrap the JSON in markdown code blocks or add any other text.`,
+            userMessage: systemPrompt,
+            messageHistory: [],
+        });
+        // Parse JSON response, handling potential markdown formatting
+        const content = response.message.replace('```json', '').replace('```', '').trim();
+        const parsed = JSON.parse(content);
+        return {
+            reasoning: parsed.reasoning || 'No reasoning provided',
+            filesToLoad: parsed.files_to_load || [],
+            estimatedTokensNeeded: parsed.estimated_tokens_needed,
+        };
+    }
+    /**
+     * Build prompt for file selection
+     */
+    buildFileSelectionPrompt(metadata, analyzedFiles, taskType, iteration, tokensUsed, remainingBudget, loadedContent, fileLimit) {
+        const taskDescriptions = {
+            readme: 'generating a comprehensive README that explains the project\'s purpose, features, and API',
+            commit: 'analyzing code changes to generate an intelligent commit message',
+            description: 'generating a concise project description for package.json',
+        };
+        const alreadyLoadedFiles = loadedContent
+            ? loadedContent.split('\n======').slice(1).map(section => {
+                const match = section.match(/START OF FILE (.+?) ======/);
+                return match ? match[1] : '';
+            }).filter(Boolean)
+            : [];
+        const availableFiles = metadata
+            .filter(m => !alreadyLoadedFiles.includes(m.relativePath))
+            .map(m => {
+            const analysis = analyzedFiles.find(a => a.path === m.path);
+            return `- ${m.relativePath} (${m.size} bytes, ~${m.estimatedTokens} tokens${analysis ? `, importance: ${analysis.importanceScore.toFixed(2)}` : ''})`;
+        })
+            .join('\n');
+        return `You are building context for ${taskDescriptions[taskType]} in a TypeScript project.
+
+ITERATION: ${iteration}
+TOKENS USED: ${tokensUsed}/${tokensUsed + remainingBudget} (${Math.round((tokensUsed / (tokensUsed + remainingBudget)) * 100)}%)
+REMAINING BUDGET: ${remainingBudget} tokens
+
+${alreadyLoadedFiles.length > 0 ? `FILES ALREADY LOADED:\n${alreadyLoadedFiles.map(f => `- ${f}`).join('\n')}\n\n` : ''}AVAILABLE FILES (not yet loaded):
+${availableFiles}
+
+Your task: Select up to ${fileLimit} files that will give you the MOST understanding for this ${taskType} task.
+
+${iteration === 1 ? `This is the FIRST iteration. Focus on:
+- Main entry points (index.ts, main exports)
+- Core classes and interfaces
+- Package configuration
+` : `This is iteration ${iteration}. You've already seen some files. Now focus on:
+- Files that complement what you've already loaded
+- Dependencies of already-loaded files
+- Missing pieces for complete understanding
+`}
+
+Consider:
+1. File importance scores (if provided)
+2. File paths (ts/index.ts is likely more important than ts/internal/utils.ts)
+3. Token efficiency (prefer smaller files if they provide good information)
+4. Remaining budget (${remainingBudget} tokens)
+
+Respond in JSON format:
+{
+  "reasoning": "Brief explanation of why you're selecting these files",
+  "files_to_load": ["path/to/file1.ts", "path/to/file2.ts"],
+  "estimated_tokens_needed": 15000
+}`;
+    }
+    /**
+     * Evaluate if current context is sufficient
+     */
+    async evaluateContextSufficiency(loadedContent, taskType, iteration, tokensUsed, remainingBudget) {
+        const prompt = `You have been building context for a ${taskType} task across ${iteration} iterations.
+
+CURRENT STATE:
+- Tokens used: ${tokensUsed}
+- Remaining budget: ${remainingBudget}
+- Files loaded: ${loadedContent.split('\n======').length - 1}
+
+CONTEXT SO FAR:
+${loadedContent.substring(0, 3000)}... (truncated for brevity)
+
+Question: Do you have SUFFICIENT context to successfully complete the ${taskType} task?
+
+Consider:
+- For README: Do you understand the project's purpose, main features, API surface, and usage patterns?
+- For commit: Do you understand what changed and why?
+- For description: Do you understand the project's core value proposition?
+
+Respond in JSON format:
+{
+  "sufficient": true or false,
+  "reasoning": "Detailed explanation of your decision"
+}`;
+        const response = await this.openaiInstance.chat({
+            systemMessage: `You are an AI assistant that evaluates whether gathered context is sufficient for a task.
+You must respond ONLY with valid JSON that can be parsed with JSON.parse().
+Do not wrap the JSON in markdown code blocks or add any other text.`,
+            userMessage: prompt,
+            messageHistory: [],
+        });
+        // Parse JSON response, handling potential markdown formatting
+        const content = response.message.replace('```json', '').replace('```', '').trim();
+        const parsed = JSON.parse(content);
+        return {
+            sufficient: parsed.sufficient || false,
+            reasoning: parsed.reasoning || 'No reasoning provided',
+        };
+    }
+    /**
+     * Load a single file with caching
+     */
+    async loadFile(filePath) {
+        // Try cache first
+        const cached = await this.cache.get(filePath);
+        if (cached) {
+            return {
+                path: filePath,
+                relativePath: plugins.path.relative(this.projectRoot, filePath),
+                contents: cached.contents,
+                tokenCount: cached.tokenCount,
+            };
+        }
+        // Load from disk
+        const contents = await plugins.smartfile.fs.toStringSync(filePath);
+        const tokenCount = this.countTokens(contents);
+        const relativePath = plugins.path.relative(this.projectRoot, filePath);
+        // Cache it
+        const stats = await fs.promises.stat(filePath);
+        await this.cache.set({
+            path: filePath,
+            contents,
+            tokenCount,
+            mtime: Math.floor(stats.mtimeMs),
+            cachedAt: Date.now(),
+        });
+        return {
+            path: filePath,
+            relativePath,
+            contents,
+            tokenCount,
+        };
+    }
+    /**
+     * Format a file for inclusion in context
+     */
+    formatFileForContext(file) {
+        return `
+====== START OF FILE ${file.relativePath} ======
+
+${file.contents}
+
+====== END OF FILE ${file.relativePath} ======
+`;
+    }
+    /**
+     * Count tokens in text
+     */
+    countTokens(text) {
+        try {
+            const tokens = plugins.gptTokenizer.encode(text);
+            return tokens.length;
+        }
+        catch (error) {
+            return Math.ceil(text.length / 4);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"iterative-context-builder.js","sourceRoot":"","sources":["../../ts/context/iterative-context-builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,EAAE,MAAM,IAAI,CAAC;AACzB,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAWvC,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD;;;GAGG;AACH,MAAM,OAAO,uBAAuB;IASlC;;;;OAIG;IACH,YAAY,WAAmB,EAAE,MAAkC;QAR3D,gBAAW,GAAW,MAAM,CAAC;QASnC,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;QAC/B,IAAI,CAAC,UAAU,GAAG,IAAI,cAAc,CAAC,WAAW,CAAC,CAAC;QAClD,IAAI,CAAC,KAAK,GAAG,IAAI,YAAY,CAAC,WAAW,CAAC,CAAC;QAC3C,IAAI,CAAC,QAAQ,GAAG,IAAI,eAAe,CAAC,WAAW,CAAC,CAAC;QAEjD,wBAAwB;QACxB,IAAI,CAAC,MAAM,GAAG;YACZ,aAAa,EAAE,MAAM,EAAE,aAAa,IAAI,CAAC;YACzC,kBAAkB,EAAE,MAAM,EAAE,kBAAkB,IAAI,EAAE;YACpD,uBAAuB,EAAE,MAAM,EAAE,uBAAuB,IAAI,CAAC;YAC7D,WAAW,EAAE,MAAM,EAAE,WAAW,IAAI,GAAG;YACvC,KAAK,EAAE,MAAM,EAAE,KAAK,IAAI,qBAAqB;SAC9C,CAAC;IAEJ,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,UAAU;QACrB,MAAM,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;QACxB,MAAM,aAAa,GAAG,aAAa,CAAC,WAAW,EAAE,CAAC;QAClD,MAAM,aAAa,CAAC,UAAU,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QACjD,IAAI,CAAC,WAAW,GAAG,aAAa,CAAC,YAAY,EAAE,CAAC;QAEhD,6BAA6B;QAC7B,MAAM,YAAY,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;QAC7C,MAAM,WAAW,GAAG,MAAM,YAAY,CAAC,iBAAiB,CAAC,cAAc,CAAC,CAAC;QACzE,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,MAAM,IAAI,KAAK,CAAC,8EAA8E,CAAC,CAAC;QAClG,CAAC;QACD,IAAI,CAAC,cAAc,GAAG,IAAI,OAAO,CAAC,OAAO,CAAC,cAAc,CAAC;YACvD,WAAW;SACZ,CAAC,CAAC;QACH,MAAM,IAAI,CAAC,cAAc,CAAC,KAAK,EAAE,CAAC;IACpC,CAAC;IAED;;;;OAIG;IACI,KAAK,CAAC,uBAAuB,CAAC,QAAkB;QACrD,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAC7B,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,2CAA2C,CAAC,CAAC;QAChE,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,YAAY,QAAQ,aAAa,IAAI,CAAC,WAAW,4BAA4B,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,CAAC,CAAC;QAE7H,2CAA2C;QAC3C,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,8BAA8B,CAAC,CAAC;QACnD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC;QACvD,MAAM,oBAAoB,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,eAAe,EAAE,CAAC,CAAC,CAAC;QACrF,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,YAAY,QAAQ,CAAC,MAAM,YAAY,oBAAoB,oBAAoB,CAAC,CAAC;QAEpG,oDAAoD;QACpD,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,kDAAkD,CAAC,CAAC;QACvE,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,QAAQ,EAAE,QAAQ,EAAE,EAAE,CAAC,CAAC;QACrE,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,2BAA2B,QAAQ,CAAC,gBAAgB,IAAI,CAAC,CAAC;QAE7E,gCAAgC;QAChC,MAAM,UAAU,GAAsB,EAAE,CAAC;QACzC,IAAI,eAAe,GAAG,CAAC,CAAC;QACxB,IAAI,YAAY,GAAG,CAAC,CAAC;QACrB,IAAI,aAAa,GAAG,EAAE,CAAC;QACvB,MAAM,aAAa,GAAgB,EAAE,CAAC;QAEtC,gDAAgD;QAChD,KAAK,IAAI,SAAS,GAAG,CAAC,EAAE,SAAS,IAAI,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,SAAS,EAAE,EAAE,CAAC;YAC5E,MAAM,cAAc,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YAClC,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,kBAAkB,SAAS,IAAI,IAAI,CAAC,MAAM,CAAC,aAAa,uCAAuC,CAAC,CAAC;YAEpH,MAAM,eAAe,GAAG,IAAI,CAAC,WAAW,GAAG,eAAe,CAAC;YAC3D,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,8BAA8B,eAAe,IAAI,IAAI,CAAC,WAAW,KAAK,IAAI,CAAC,KAAK,CAAC,CAAC,eAAe,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC;YAErJ,yCAAyC;YACzC,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,wBAAwB,CAClD,QAAQ,EACR,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,6BAA6B;YAC1D,QAAQ,EACR,SAAS,EACT,eAAe,EACf,eAAe,EACf,aAAa,CACd,CAAC;YACF,YAAY,EAAE,CAAC;YAEf,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,oBAAoB,QAAQ,CAAC,SAAS,EAAE,CAAC,CAAC;YAC7D,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,mBAAmB,QAAQ,CAAC,WAAW,CAAC,MAAM,QAAQ,CAAC,CAAC;YAE3E,uBAAuB;YACvB,MAAM,cAAc,GAAgB,EAAE,CAAC;YACvC,IAAI,eAAe,GAAG,CAAC,CAAC;YAExB,IAAI,QAAQ,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACpC,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,+BAA+B,CAAC,CAAC;gBAEpD,KAAK,MAAM,QAAQ,IAAI,QAAQ,CAAC,WAAW,EAAE,CAAC;oBAC5C,IAAI,CAAC;wBACH,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;wBAC/C,IAAI,eAAe,GAAG,QAAQ,CAAC,UAAW,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;4BAC/D,MAAM,aAAa,GAAG,IAAI,CAAC,oBAAoB,CAAC,QAAQ,CAAC,CAAC;4BAC1D,aAAa,IAAI,aAAa,CAAC;4BAC/B,aAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;4BAC7B,cAAc,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;4BAC9B,eAAe,IAAI,QAAQ,CAAC,UAAW,CAAC;4BACxC,eAAe,IAAI,QAAQ,CAAC,UAAW,CAAC;4BAExC,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,QAAQ,CAAC,YAAY,KAAK,QAAQ,CAAC,UAAU,UAAU,CAAC,CAAC;wBACtF,CAAC;6BAAM,CAAC;4BACN,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,QAAQ,CAAC,YAAY,kCAAkC,CAAC,CAAC;wBACtF,CAAC;oBACH,CAAC;oBAAC,OAAO,KAAK,EAAE,CAAC;wBACf,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,uBAAuB,QAAQ,KAAK,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;oBAC1E,CAAC;gBACH,CAAC;YACH,CAAC;YAED,yBAAyB;YACzB,MAAM,iBAAiB,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,cAAc,CAAC;YACtD,UAAU,CAAC,IAAI,CAAC;gBACd,SAAS;gBACT,WAAW,EAAE,cAAc;gBAC3B,UAAU,EAAE,eAAe;gBAC3B,eAAe;gBACf,QAAQ;gBACR,QAAQ,EAAE,iBAAiB;aAC5B,CAAC,CAAC;YAEH,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,gBAAgB,SAAS,cAAc,cAAc,CAAC,MAAM,kBAAkB,eAAe,cAAc,CAAC,CAAC;YAEhI,8BAA8B;YAC9B,IAAI,eAAe,IAAI,IAAI,CAAC,WAAW,GAAG,IAAI,EAAE,CAAC;gBAC/C,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,yDAAyD,CAAC,CAAC;gBAC9E,MAAM;YACR,CAAC;YAED,kCAAkC;YAClC,IAAI,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,CAAC;gBAC1C,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,0CAA0C,CAAC,CAAC;gBAC/D,MAAM,mBAAmB,GAAG,MAAM,IAAI,CAAC,0BAA0B,CAC/D,aAAa,EACb,QAAQ,EACR,SAAS,EACT,eAAe,EACf,eAAe,GAAG,eAAe,CAClC,CAAC;gBACF,YAAY,EAAE,CAAC;gBAEf,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,mBAAmB,mBAAmB,CAAC,UAAU,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,gBAAgB,EAAE,CAAC,CAAC;gBAC5G,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,iBAAiB,mBAAmB,CAAC,SAAS,EAAE,CAAC,CAAC;gBAErE,IAAI,mBAAmB,CAAC,UAAU,EAAE,CAAC;oBACnC,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,mEAAmE,CAAC,CAAC;oBACtF,MAAM;gBACR,CAAC;YACH,CAAC;QACH,CAAC;QAED,MAAM,aAAa,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,CAAC;QAC7C,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,0CAA0C,CAAC,CAAC;QAC7D,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,sBAAsB,aAAa,CAAC,MAAM,EAAE,CAAC,CAAC;QACjE,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,mBAAmB,eAAe,IAAI,IAAI,CAAC,WAAW,KAAK,IAAI,CAAC,KAAK,CAAC,CAAC,eAAe,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC;QAC1I,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,kBAAkB,UAAU,CAAC,MAAM,gBAAgB,YAAY,EAAE,CAAC,CAAC;QACtF,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,sBAAsB,CAAC,aAAa,GAAG,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QAE/E,OAAO;YACL,OAAO,EAAE,aAAa;YACtB,UAAU,EAAE,eAAe;YAC3B,aAAa;YACb,YAAY,EAAE,EAAE;YAChB,aAAa,EAAE,EAAE;YACjB,YAAY,EAAE,CAAC;YACf,cAAc,EAAE,UAAU,CAAC,MAAM;YACjC,UAAU;YACV,YAAY;YACZ,aAAa;SACd,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,gBAAgB,CAAC,QAAkB;QAC/C,MAAM,aAAa,GAAG,aAAa,CAAC,WAAW,EAAE,CAAC;QAClD,MAAM,UAAU,GAAG,aAAa,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;QAEzD,MAAM,YAAY,GAAG,UAAU,EAAE,YAAY,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI;YACzE,YAAY;YACZ,aAAa;SACd,CAAC;QAEF,MAAM,WAAW,GAAG;YAClB,cAAc;YACd,WAAW;YACX,iBAAiB;YACjB,eAAe;SAChB,CAAC;QAEF,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,GAAG,WAAW,EAAE,GAAG,YAAY,CAAC,CAAC,CAAC;IAC5E,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,wBAAwB,CACpC,WAA4B,EAC5B,aAAoB,EACpB,QAAkB,EAClB,SAAiB,EACjB,UAAkB,EAClB,eAAuB,EACvB,aAAqB;QAErB,MAAM,gBAAgB,GAAG,SAAS,KAAK,CAAC,CAAC;QACzC,MAAM,SAAS,GAAG,gBAAgB;YAChC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,kBAAkB;YAChC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,uBAAuB,CAAC;QAExC,MAAM,YAAY,GAAG,IAAI,CAAC,wBAAwB,CAChD,WAAW,EACX,aAAa,EACb,QAAQ,EACR,SAAS,EACT,UAAU,EACV,eAAe,EACf,aAAa,EACb,SAAS,CACV,CAAC;QAEF,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC;YAC9C,aAAa,EAAE;;oEAE+C;YAC9D,WAAW,EAAE,YAAY;YACzB,cAAc,EAAE,EAAE;SACnB,CAAC,CAAC;QAEH,8DAA8D;QAC9D,MAAM,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;QAClF,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAEnC,OAAO;YACL,SAAS,EAAE,MAAM,CAAC,SAAS,IAAI,uBAAuB;YACtD,WAAW,EAAE,MAAM,CAAC,aAAa,IAAI,EAAE;YACvC,qBAAqB,EAAE,MAAM,CAAC,uBAAuB;SACtD,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,wBAAwB,CAC9B,QAAyB,EACzB,aAAoB,EACpB,QAAkB,EAClB,SAAiB,EACjB,UAAkB,EAClB,eAAuB,EACvB,aAAqB,EACrB,SAAiB;QAEjB,MAAM,gBAAgB,GAAG;YACvB,MAAM,EAAE,2FAA2F;YACnG,MAAM,EAAE,kEAAkE;YAC1E,WAAW,EAAE,2DAA2D;SACzE,CAAC;QAEF,MAAM,kBAAkB,GAAG,aAAa;YACtC,CAAC,CAAC,aAAa,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE;gBACrD,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,4BAA4B,CAAC,CAAC;gBAC1D,OAAO,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAC/B,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC;YACpB,CAAC,CAAC,EAAE,CAAC;QAEP,MAAM,cAAc,GAAG,QAAQ;aAC5B,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC;aACzD,GAAG,CAAC,CAAC,CAAC,EAAE;YACP,MAAM,QAAQ,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC;YAC5D,OAAO,KAAK,CAAC,CAAC,YAAY,KAAK,CAAC,CAAC,IAAI,YAAY,CAAC,CAAC,eAAe,UAAU,QAAQ,CAAC,CAAC,CAAC,iBAAiB,QAAQ,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC;QACxJ,CAAC,CAAC;aACD,IAAI,CAAC,IAAI,CAAC,CAAC;QAEd,OAAO,gCAAgC,gBAAgB,CAAC,QAAQ,CAAC;;aAExD,SAAS;eACP,UAAU,IAAI,UAAU,GAAG,eAAe,KAAK,IAAI,CAAC,KAAK,CAAC,CAAC,UAAU,GAAG,CAAC,UAAU,GAAG,eAAe,CAAC,CAAC,GAAG,GAAG,CAAC;oBACzG,eAAe;;EAEjC,kBAAkB,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,0BAA0B,kBAAkB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE;EACrH,cAAc;;0BAEU,SAAS,6DAA6D,QAAQ;;EAEtG,SAAS,KAAK,CAAC,CAAC,CAAC,CAAC;;;;CAInB,CAAC,CAAC,CAAC,qBAAqB,SAAS;;;;CAIjC;;;;;;uBAMsB,eAAe;;;;;;;EAOpC,CAAC;IACD,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,0BAA0B,CACtC,aAAqB,EACrB,QAAkB,EAClB,SAAiB,EACjB,UAAkB,EAClB,eAAuB;QAEvB,MAAM,MAAM,GAAG,wCAAwC,QAAQ,gBAAgB,SAAS;;;iBAG3E,UAAU;sBACL,eAAe;kBACnB,aAAa,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,MAAM,GAAG,CAAC;;;EAG1D,aAAa,CAAC,SAAS,CAAC,CAAC,EAAE,IAAI,CAAC;;wEAEsC,QAAQ;;;;;;;;;;;EAW9E,CAAC;QAEC,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC;YAC9C,aAAa,EAAE;;oEAE+C;YAC9D,WAAW,EAAE,MAAM;YACnB,cAAc,EAAE,EAAE;SACnB,CAAC,CAAC;QAEH,8DAA8D;QAC9D,MAAM,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;QAClF,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAEnC,OAAO;YACL,UAAU,EAAE,MAAM,CAAC,UAAU,IAAI,KAAK;YACtC,SAAS,EAAE,MAAM,CAAC,SAAS,IAAI,uBAAuB;SACvD,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,QAAQ,CAAC,QAAgB;QACrC,kBAAkB;QAClB,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAC9C,IAAI,MAAM,EAAE,CAAC;YACX,OAAO;gBACL,IAAI,EAAE,QAAQ;gBACd,YAAY,EAAE,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,EAAE,QAAQ,CAAC;gBAC/D,QAAQ,EAAE,MAAM,CAAC,QAAQ;gBACzB,UAAU,EAAE,MAAM,CAAC,UAAU;aAC9B,CAAC;QACJ,CAAC;QAED,iBAAiB;QACjB,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;QACnE,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;QAC9C,MAAM,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC;QAEvE,WAAW;QACX,MAAM,KAAK,GAAG,MAAM,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC/C,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC;YACnB,IAAI,EAAE,QAAQ;YACd,QAAQ;YACR,UAAU;YACV,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC;YAChC,QAAQ,EAAE,IAAI,CAAC,GAAG,EAAE;SACrB,CAAC,CAAC;QAEH,OAAO;YACL,IAAI,EAAE,QAAQ;YACd,YAAY;YACZ,QAAQ;YACR,UAAU;SACX,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,oBAAoB,CAAC,IAAe;QAC1C,OAAO;uBACY,IAAI,CAAC,YAAY;;EAEtC,IAAI,CAAC,QAAQ;;qBAEM,IAAI,CAAC,YAAY;CACrC,CAAC;IACA,CAAC;IAED;;OAEG;IACK,WAAW,CAAC,IAAY;QAC9B,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YACjD,OAAO,MAAM,CAAC,MAAM,CAAC;QACvB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QACpC,CAAC;IACH,CAAC;CACF"}

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

@@ -1,6 +1,6 @@
-import type { IContextResult, TaskType } from './types.js';
+import type { IIterativeContextResult, TaskType } from './types.js';
 /**
- * Factory class for creating task-specific context
+ * Factory class for creating task-specific context using iterative context building
  */
 export declare class TaskContextFactory {
     private projectDir;
@@ -17,22 +17,22 @@ export declare class TaskContextFactory {
     /**
      * Create context for README generation
      */
-    createContextForReadme(): Promise<IContextResult>;
+    createContextForReadme(): Promise<IIterativeContextResult>;
     /**
      * Create context for description generation
      */
-    createContextForDescription(): Promise<IContextResult>;
+    createContextForDescription(): Promise<IIterativeContextResult>;
     /**
      * Create context for commit message generation
-     * @param gitDiff Optional git diff to include
+     * @param gitDiff Optional git diff to include (currently not used in iterative mode)
      */
-    createContextForCommit(gitDiff?: string): Promise<IContextResult>;
+    createContextForCommit(gitDiff?: string): Promise<IIterativeContextResult>;
     /**
      * Create context for any task type
      * @param taskType The task type to create context for
-     * @param additionalContent Optional additional content to include
+     * @param additionalContent Optional additional content (currently not used)
      */
-    createContextForTask(taskType: TaskType, additionalContent?: string): Promise<IContextResult>;
+    createContextForTask(taskType: TaskType, additionalContent?: string): Promise<IIterativeContextResult>;
     /**
      * Get token stats for all task types
      */

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

@@ -1,8 +1,8 @@
 import * as plugins from '../plugins.js';
-import { EnhancedContext } from './enhanced-context.js';
+import { IterativeContextBuilder } from './iterative-context-builder.js';
 import { ConfigManager } from './config-manager.js';
 /**
- * Factory class for creating task-specific context
+ * Factory class for creating task-specific context using iterative context building
  */
 export class TaskContextFactory {
     /**
@@ -23,54 +23,32 @@ export class TaskContextFactory {
      * 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');
+        const iterativeBuilder = new IterativeContextBuilder(this.projectDir, this.configManager.getIterativeConfig());
+        await iterativeBuilder.initialize();
+        return await iterativeBuilder.buildContextIteratively('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');
+        const iterativeBuilder = new IterativeContextBuilder(this.projectDir, this.configManager.getIterativeConfig());
+        await iterativeBuilder.initialize();
+        return await iterativeBuilder.buildContextIteratively('description');
     }
     /**
      * Create context for commit message generation
-     * @param gitDiff Optional git diff to include
+     * @param gitDiff Optional git diff to include (currently not used in iterative mode)
      */
     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();
+        const iterativeBuilder = new IterativeContextBuilder(this.projectDir, this.configManager.getIterativeConfig());
+        await iterativeBuilder.initialize();
+        // Note: git diff could be incorporated into the iterative prompts if needed
+        return await iterativeBuilder.buildContextIteratively('commit');
     }
     /**
      * Create context for any task type
      * @param taskType The task type to create context for
-     * @param additionalContent Optional additional content to include
+     * @param additionalContent Optional additional content (currently not used)
      */
     async createContextForTask(taskType, additionalContent) {
         switch (taskType) {
@@ -81,10 +59,8 @@ export class TaskContextFactory {
             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();
+                // Default to readme for unknown task types
+                return this.createContextForReadme();
         }
     }
     /**
@@ -106,4 +82,4 @@ export class TaskContextFactory {
         return stats;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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