codehere 0.2.2 → 0.3.0-rc.1

package/dist/domain/services/react-loop.js

@@ -1,186 +0,0 @@
-/**
- * Domain Service: ReAct Loop
- * Implements Thought → Action → Observation cycle
- */
-export class ReActLoop {
-    maxTurns;
-    trajectory = null;
-    consecutiveFailures = 0;
-    maxConsecutiveFailures = 3;
-    recentToolCalls = new Map(); // Track repeated tool calls
-    recentActions = []; // Track recent action types for diversity check
-    noProgressTurns = 0; // Track turns with no progress
-    maxNoProgressTurns = 5; // Max turns without progress before early termination
-    lastObservationHash = null; // Track if observations are changing
-    constructor(maxTurns = 20) {
-        this.maxTurns = maxTurns;
-    }
-    /**
-     * Execute ReAct loop with infinite loop prevention
-     */
-    async execute(query, context, generateThought, generateAction, executeAction, isFinalAnswer) {
-        this.trajectory = {
-            query,
-            steps: [],
-            success: false,
-        };
-        this.consecutiveFailures = 0;
-        this.recentToolCalls.clear();
-        this.recentActions = [];
-        this.noProgressTurns = 0;
-        this.lastObservationHash = null;
-        for (let turn = 0; turn < this.maxTurns; turn++) {
-            // 1. Generate Thought
-            const thought = await generateThought(query, context, this.trajectory);
-            // 2. Generate Action
-            const action = await generateAction(thought, context);
-            // 3. Action Diversity Check - Don't repeat same action type consecutively
-            const actionKey = `${action.type}:${action.name}`;
-            if (this.recentActions.length > 0 && this.recentActions[this.recentActions.length - 1] === actionKey) {
-                // Same action type repeated consecutively - likely stuck
-                this.trajectory.steps.push({
-                    thought,
-                    action,
-                    observation: {
-                        result: null,
-                        success: false,
-                        error: `Action diversity violation: Same action "${actionKey}" repeated consecutively. Stopping to prevent infinite loop.`,
-                    },
-                    timestamp: new Date(),
-                });
-                this.trajectory.success = false;
-                break;
-            }
-            this.recentActions.push(actionKey);
-            // Keep only last 5 actions for diversity check
-            if (this.recentActions.length > 5) {
-                this.recentActions.shift();
-            }
-            // 4. Check for repeated tool calls (infinite loop detection)
-            if (action.type === 'tool') {
-                const toolKey = `${action.name}:${JSON.stringify(action.parameters || {})}`;
-                const callCount = this.recentToolCalls.get(toolKey) || 0;
-                if (callCount >= 2) {
-                    // Same tool called 3+ times with same parameters - likely stuck
-                    this.trajectory.steps.push({
-                        thought,
-                        action,
-                        observation: {
-                            result: null,
-                            success: false,
-                            error: `Infinite loop detected: Tool "${action.name}" called ${callCount + 1} times with same parameters. Stopping to prevent infinite loop.`,
-                        },
-                        timestamp: new Date(),
-                    });
-                    this.trajectory.success = false;
-                    break;
-                }
-                this.recentToolCalls.set(toolKey, callCount + 1);
-                // Clean old entries (keep only last 10 unique tool calls)
-                if (this.recentToolCalls.size > 10) {
-                    const entries = Array.from(this.recentToolCalls.entries());
-                    this.recentToolCalls.clear();
-                    entries.slice(-10).forEach(([key, value]) => {
-                        this.recentToolCalls.set(key, value);
-                    });
-                }
-            }
-            // 5. Execute Action
-            const observation = await executeAction(action);
-            // 6. Track consecutive failures
-            if (!observation.success) {
-                this.consecutiveFailures++;
-                if (this.consecutiveFailures >= this.maxConsecutiveFailures) {
-                    // Too many consecutive failures - stop to prevent infinite loop
-                    this.trajectory.steps.push({
-                        thought,
-                        action,
-                        observation: {
-                            result: null,
-                            success: false,
-                            error: `Too many consecutive failures (${this.consecutiveFailures}). Stopping to prevent infinite loop. Last error: ${observation.error || 'Unknown error'}`,
-                        },
-                        timestamp: new Date(),
-                    });
-                    this.trajectory.success = false;
-                    break;
-                }
-            }
-            else {
-                // Reset failure counter on success
-                this.consecutiveFailures = 0;
-            }
-            // 7. Check for progress (observation changed)
-            const observationHash = this.hashObservation(observation);
-            if (observationHash === this.lastObservationHash && !observation.success) {
-                // Same observation result repeated - no progress
-                this.noProgressTurns++;
-                if (this.noProgressTurns >= this.maxNoProgressTurns) {
-                    this.trajectory.steps.push({
-                        thought,
-                        action,
-                        observation: {
-                            result: observation.result,
-                            success: false,
-                            error: `No progress detected after ${this.noProgressTurns} turns. Stopping to prevent infinite loop.`,
-                        },
-                        timestamp: new Date(),
-                    });
-                    this.trajectory.success = false;
-                    break;
-                }
-            }
-            else {
-                // Progress detected - reset counter
-                this.noProgressTurns = 0;
-                this.lastObservationHash = observationHash;
-            }
-            // 8. Record step
-            const step = {
-                thought,
-                action,
-                observation,
-                timestamp: new Date(),
-            };
-            this.trajectory.steps.push(step);
-            // 9. Check if done
-            if (isFinalAnswer(observation)) {
-                this.trajectory.finalAnswer = observation.result;
-                this.trajectory.success = true;
-                break;
-            }
-            // 10. Update context with observation
-            context = { ...context, lastObservation: observation };
-        }
-        // Check if we hit max turns without success
-        if (!this.trajectory.success && this.trajectory.steps.length >= this.maxTurns) {
-            const lastStep = this.trajectory.steps[this.trajectory.steps.length - 1];
-            if (lastStep && !lastStep.observation.error) {
-                // Add error if we hit max turns
-                lastStep.observation.error = `Reached maximum turns (${this.maxTurns}) without finding solution.`;
-            }
-        }
-        return this.trajectory;
-    }
-    getTrajectory() {
-        if (!this.trajectory) {
-            throw new Error('Trajectory not initialized. Execute loop first.');
-        }
-        return this.trajectory;
-    }
-    /**
-     * Hash observation to detect if it's changed (progress detection)
-     */
-    hashObservation(observation) {
-        const key = `${observation.success}:${observation.error || ''}:${JSON.stringify(observation.result || '').substring(0, 100)}`;
-        // Simple hash function
-        let hash = 0;
-        for (let i = 0; i < key.length; i++) {
-            const char = key.charCodeAt(i);
-            hash = ((hash << 5) - hash) + char;
-            hash = hash & hash; // Convert to 32-bit integer
-        }
-        return hash.toString();
-    }
-}
-//# sourceMappingURL=react-loop.js.map

package/dist/domain/services/risk-tier-detector.js

@@ -1,78 +0,0 @@
-/**
- * Risk Tier Detector
- * Detects risk tier for operations
- *
- * Phase 1: v0.5.0-alpha.0
- */
-import { RiskTier } from '../entities/task.js';
-/**
- * Detect risk tier from file list
- */
-export function detectRiskTier(files) {
-    if (!files || files.length === 0) {
-        return RiskTier.T1;
-    }
-    // Check for high-risk file patterns
-    const highRiskPatterns = [
-        /\.(env|secret|key|pem|p12|pfx)$/i, // Secrets
-        /package\.json$/i, // Dependencies
-        /\.lock$/i, // Lock files
-        /Dockerfile/i, // Container configs
-        /\.config\.(js|ts|json)$/i, // Config files
-        /config\/.*\.(yml|yaml|json|toml|ini)$/i, // Config directory files
-        /^config\//i, // Files in config directory (any file in config/)
-        /\/config\//i, // Files in config directory (anywhere in path)
-    ];
-    const criticalPatterns = [
-        /\.(sql|db|sqlite)$/i, // Databases
-        /\.(sh|bat|ps1)$/i, // Scripts
-    ];
-    // First pass: check ALL files for critical patterns (T3)
-    for (const file of files) {
-        for (const pattern of criticalPatterns) {
-            if (pattern.test(file)) {
-                return RiskTier.T3;
-            }
-        }
-    }
-    // Second pass: check ALL files for high-risk patterns (T2)
-    for (const file of files) {
-        for (const pattern of highRiskPatterns) {
-            if (pattern.test(file)) {
-                return RiskTier.T2;
-            }
-        }
-    }
-    // Multi-file operations are medium risk
-    if (files.length > 3) {
-        return RiskTier.T2;
-    }
-    return RiskTier.T1;
-}
-/**
- * Detect risk tier from plan
- */
-export function detectRiskTierFromPlan(plan) {
-    if (!plan) {
-        return RiskTier.T1;
-    }
-    // Check sub-plans for high-risk operations
-    const subPlans = plan.subPlans || [];
-    const highRiskTypes = ['refactor', 'implement', 'test'];
-    const criticalTypes = ['delete', 'move'];
-    for (const subPlan of subPlans) {
-        const type = subPlan.type?.toLowerCase();
-        if (criticalTypes.includes(type)) {
-            return RiskTier.T3;
-        }
-        if (highRiskTypes.includes(type)) {
-            return RiskTier.T2;
-        }
-    }
-    // Large plans are medium risk
-    if (subPlans.length > 5) {
-        return RiskTier.T2;
-    }
-    return RiskTier.T1;
-}
-//# sourceMappingURL=risk-tier-detector.js.map

package/dist/edit.js

@@ -1,319 +0,0 @@
-import { readFileSync, writeFileSync, existsSync } from 'fs';
-import { join } from 'path';
-import { generateDiff } from './chat.js';
-import { checkPolicy } from './policy.js';
-import { refineTask } from './iterative-refinement.js';
-/**
- * Fix duplicate module.exports or export statements
- */
-function fixDuplicateExports(content) {
-    const lines = content.split('\n');
-    const result = [];
-    let foundModuleExports = false;
-    let foundExport = false;
-    let lastExportIndex = -1;
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i].trim();
-        // Check for module.exports
-        if (line.startsWith('module.exports')) {
-            if (foundModuleExports) {
-                // Skip duplicate - keep the last one
-                // Remove previous export from result
-                if (lastExportIndex >= 0) {
-                    result.splice(lastExportIndex, 1);
-                }
-                lastExportIndex = result.length;
-                result.push(lines[i]);
-            }
-            else {
-                foundModuleExports = true;
-                lastExportIndex = result.length;
-                result.push(lines[i]);
-            }
-        }
-        // Check for ES6 export default
-        else if (line.startsWith('export default')) {
-            if (foundExport) {
-                // Skip duplicate
-                if (lastExportIndex >= 0) {
-                    result.splice(lastExportIndex, 1);
-                }
-                lastExportIndex = result.length;
-                result.push(lines[i]);
-            }
-            else {
-                foundExport = true;
-                lastExportIndex = result.length;
-                result.push(lines[i]);
-            }
-        }
-        // Check for ES6 export const/function/class
-        else if (line.match(/^export\s+(const|function|class|let|var)\s+/)) {
-            // These are usually fine (one per line), but check for duplicates
-            result.push(lines[i]);
-        }
-        else {
-            result.push(lines[i]);
-        }
-    }
-    return result.join('\n');
-}
-export function parseDiffStats(diffText) {
-    const lines = diffText.split('\n');
-    let linesAdded = 0;
-    let linesRemoved = 0;
-    let filesChanged = 0;
-    let currentFile = '';
-    for (const line of lines) {
-        if (line.startsWith('---')) {
-            const fileMatch = line.match(/^---\s+(.+)$/);
-            if (fileMatch && fileMatch[1] !== '/dev/null') {
-                const file = fileMatch[1].replace(/^a\//, '');
-                if (file !== currentFile) {
-                    filesChanged++;
-                    currentFile = file;
-                }
-            }
-        }
-        else if (line.startsWith('+++')) {
-            const fileMatch = line.match(/^\+\+\+\s+(.+)$/);
-            if (fileMatch && fileMatch[1] !== '/dev/null') {
-                const file = fileMatch[1].replace(/^b\//, '');
-                if (file !== currentFile) {
-                    filesChanged++;
-                    currentFile = file;
-                }
-            }
-        }
-        else if (line.startsWith('+') && !line.startsWith('+++')) {
-            linesAdded++;
-        }
-        else if (line.startsWith('-') && !line.startsWith('---')) {
-            linesRemoved++;
-        }
-    }
-    return { linesAdded, linesRemoved, filesChanged };
-}
-export function applyUnifiedDiff(originalContent, diffText) {
-    const diffLines = diffText.split('\n');
-    const originalLines = originalContent.split('\n');
-    const result = [];
-    let originalIndex = 0;
-    let i = 0;
-    // Find first hunk
-    while (i < diffLines.length && !diffLines[i].startsWith('@@')) {
-        i++;
-    }
-    while (i < diffLines.length) {
-        const line = diffLines[i];
-        if (line.startsWith('@@')) {
-            // Hunk header: @@ -start,count +start,count @@
-            const match = line.match(/^@@\s+-(\d+)(?:,(\d+))?\s+\+(\d+)(?:,(\d+))?\s+@@/);
-            if (match) {
-                const oldStart = parseInt(match[1], 10) - 1; // Convert to 0-based (line numbers are 1-based)
-                const oldCount = match[2] ? parseInt(match[2], 10) : 0;
-                // Add lines before this hunk
-                while (originalIndex < oldStart && originalIndex < originalLines.length) {
-                    result.push(originalLines[originalIndex]);
-                    originalIndex++;
-                }
-                i++; // Move past hunk header
-                // Process hunk lines
-                let removedCount = 0;
-                while (i < diffLines.length) {
-                    const hunkLine = diffLines[i];
-                    // Check for next hunk
-                    if (hunkLine.startsWith('@@')) {
-                        break;
-                    }
-                    if (hunkLine.startsWith('+') && !hunkLine.startsWith('+++')) {
-                        // Added line
-                        result.push(hunkLine.substring(1));
-                        i++;
-                    }
-                    else if (hunkLine.startsWith('-') && !hunkLine.startsWith('---')) {
-                        // Removed line - skip it in original
-                        originalIndex++;
-                        removedCount++;
-                        i++;
-                    }
-                    else if (hunkLine.startsWith(' ')) {
-                        // Context line - keep from original
-                        if (originalIndex < originalLines.length) {
-                            result.push(originalLines[originalIndex]);
-                        }
-                        originalIndex++;
-                        removedCount++;
-                        i++;
-                    }
-                    else if (hunkLine.trim() === '') {
-                        // Empty line, skip
-                        i++;
-                    }
-                    else {
-                        // Unknown line type, skip
-                        i++;
-                    }
-                    // Safety check: if we've processed all expected removed lines, we might be done
-                    if (oldCount > 0 && removedCount >= oldCount && !diffLines[i]?.startsWith('@@')) {
-                        // Check if next line is part of this hunk or next
-                        if (i < diffLines.length && !diffLines[i].startsWith('@@') && !diffLines[i].startsWith('+') && !diffLines[i].startsWith('-') && !diffLines[i].startsWith(' ')) {
-                            break;
-                        }
-                    }
-                }
-            }
-            else {
-                i++;
-            }
-        }
-        else {
-            i++;
-        }
-    }
-    // Add remaining original lines
-    while (originalIndex < originalLines.length) {
-        result.push(originalLines[originalIndex]);
-        originalIndex++;
-    }
-    return result.join('\n');
-}
-/**
- * Legacy function - kept for backward compatibility
- * Use generateAndApplyEditWithVerification() for new code
- */
-export async function generateAndApplyEdit(filepath, instruction) {
-    const fullPath = join(process.cwd(), filepath);
-    if (!existsSync(fullPath)) {
-        return {
-            success: false,
-            error: `File not found: ${filepath}`,
-        };
-    }
-    const originalContent = readFileSync(fullPath, 'utf-8');
-    // Generate diff
-    const diffText = await generateDiff(originalContent, instruction, filepath);
-    if (!diffText || diffText.trim().length === 0) {
-        return {
-            success: false,
-            error: 'No diff generated',
-        };
-    }
-    // Parse diff stats
-    const diffStats = parseDiffStats(diffText);
-    // Check policy
-    const policyResult = checkPolicy(filepath, diffStats);
-    if (!policyResult.allowed) {
-        return {
-            success: false,
-            policyResult,
-            diffStats,
-            error: policyResult.reason,
-        };
-    }
-    // Apply diff
-    try {
-        const newContent = applyUnifiedDiff(originalContent, diffText);
-        writeFileSync(fullPath, newContent, 'utf-8');
-        return {
-            success: true,
-            diffStats,
-            policyResult,
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            diffStats,
-            policyResult,
-            error: `Failed to apply diff: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-}
-/**
- * NEW: Generate and apply edit with verification and iterative refinement
- */
-export async function generateAndApplyEditWithVerification(filepath, instruction, requirements) {
-    const fullPath = join(process.cwd(), filepath);
-    if (!existsSync(fullPath)) {
-        return {
-            success: false,
-            verified: false,
-            iterations: 0,
-            error: `File not found: ${filepath}`,
-        };
-    }
-    try {
-        // Read original content BEFORE modification
-        const originalContent = readFileSync(fullPath, 'utf-8');
-        // Use iterative refinement with verification
-        const refinementResult = await refineTask(fullPath, instruction, requirements, 3);
-        if (!refinementResult.success) {
-            // Rollback on failure
-            writeFileSync(fullPath, originalContent, 'utf-8');
-            return {
-                success: false,
-                verified: false,
-                iterations: refinementResult.iterations,
-                error: `Task failed after ${refinementResult.iterations} iterations`,
-                verificationErrors: refinementResult.finalResult.errors,
-            };
-        }
-        // Read final content and calculate actual diff stats
-        const finalContent = readFileSync(fullPath, 'utf-8');
-        // Calculate diff stats manually (more reliable than generating diff)
-        const originalLines = originalContent.split('\n');
-        const finalLines = finalContent.split('\n');
-        let linesAdded = 0;
-        let linesRemoved = 0;
-        // Simple line-by-line comparison
-        const maxLen = Math.max(originalLines.length, finalLines.length);
-        for (let i = 0; i < maxLen; i++) {
-            if (i >= originalLines.length) {
-                linesAdded++;
-            }
-            else if (i >= finalLines.length) {
-                linesRemoved++;
-            }
-            else if (originalLines[i] !== finalLines[i]) {
-                // Changed line - count as removed + added
-                linesRemoved++;
-                linesAdded++;
-            }
-        }
-        const diffStats = {
-            linesAdded,
-            linesRemoved,
-            filesChanged: 1,
-        };
-        // Check policy
-        const policyResult = checkPolicy(filepath, diffStats);
-        return {
-            success: true,
-            verified: refinementResult.finalResult.success,
-            iterations: refinementResult.iterations,
-            diffStats,
-            policyResult,
-            verificationErrors: refinementResult.finalResult.errors.length > 0 ? refinementResult.finalResult.errors : undefined,
-        };
-    }
-    catch (error) {
-        // Rollback on error
-        if (existsSync(fullPath)) {
-            try {
-                const originalContent = readFileSync(fullPath, 'utf-8');
-                // Try to restore if we have backup (refinement should have kept original)
-            }
-            catch {
-                // Ignore rollback errors
-            }
-        }
-        return {
-            success: false,
-            verified: false,
-            iterations: 0,
-            error: `Error during verification: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-}
-//# sourceMappingURL=edit.js.map