@compilr-dev/agents 0.0.1

package/dist/rate-limit/types.d.ts

@@ -0,0 +1,181 @@
+/**
+ * Rate Limiting & Retry Types
+ *
+ * Provides types for rate limiting and automatic retry functionality.
+ */
+/**
+ * Configuration for rate limiter
+ */
+export interface RateLimiterConfig {
+    /**
+     * Maximum requests per minute
+     * @default 60
+     */
+    requestsPerMinute?: number;
+    /**
+     * Maximum tokens per minute (for token-based limiting)
+     * Set to 0 to disable token-based limiting
+     * @default 0
+     */
+    tokensPerMinute?: number;
+    /**
+     * Maximum concurrent requests
+     * Set to 0 for unlimited
+     * @default 0
+     */
+    maxConcurrent?: number;
+    /**
+     * Whether to throw immediately when rate limited instead of waiting
+     * @default false
+     */
+    throwOnLimit?: boolean;
+}
+/**
+ * Rate limiter statistics
+ */
+export interface RateLimiterStats {
+    /**
+     * Current number of available request tokens
+     */
+    availableRequests: number;
+    /**
+     * Current number of available LLM tokens
+     */
+    availableTokens: number;
+    /**
+     * Current number of concurrent requests
+     */
+    currentConcurrent: number;
+    /**
+     * Total requests made
+     */
+    totalRequests: number;
+    /**
+     * Total tokens consumed
+     */
+    totalTokens: number;
+    /**
+     * Number of times rate limit was hit
+     */
+    rateLimitHits: number;
+    /**
+     * Total time spent waiting due to rate limits (ms)
+     */
+    totalWaitTimeMs: number;
+}
+/**
+ * Configuration for automatic retry
+ */
+export interface RetryConfig {
+    /**
+     * Maximum number of retry attempts
+     * @default 3
+     */
+    maxRetries?: number;
+    /**
+     * Base delay between retries in milliseconds
+     * @default 1000
+     */
+    baseDelayMs?: number;
+    /**
+     * Maximum delay between retries in milliseconds
+     * @default 60000
+     */
+    maxDelayMs?: number;
+    /**
+     * Multiplier for exponential backoff
+     * @default 2
+     */
+    backoffMultiplier?: number;
+    /**
+     * Whether to add random jitter to delays
+     * @default true
+     */
+    jitter?: boolean;
+    /**
+     * Custom function to determine if an error is retryable
+     * If not provided, uses default logic (429, 5xx, connection errors)
+     */
+    isRetryable?: (error: Error) => boolean;
+    /**
+     * Callback invoked before each retry attempt
+     */
+    onRetry?: (attempt: number, error: Error, delayMs: number) => void;
+}
+/**
+ * Combined rate limit and retry configuration
+ */
+export interface RateLimitRetryConfig {
+    /**
+     * Rate limiter configuration
+     */
+    rateLimit?: RateLimiterConfig;
+    /**
+     * Retry configuration
+     */
+    retry?: RetryConfig;
+}
+/**
+ * Result of acquiring a rate limit token
+ */
+export interface AcquireResult {
+    /**
+     * Whether the acquisition was successful
+     */
+    acquired: boolean;
+    /**
+     * Time waited to acquire the token (ms)
+     */
+    waitedMs: number;
+    /**
+     * If not acquired, the estimated wait time (ms)
+     */
+    estimatedWaitMs?: number;
+}
+/**
+ * Rate limiter interface
+ */
+export interface RateLimiter {
+    /**
+     * Acquire permission to make a request
+     * Waits if necessary (unless throwOnLimit is true)
+     *
+     * @param estimatedTokens - Estimated tokens for the request (optional)
+     * @returns Acquire result
+     */
+    acquire(estimatedTokens?: number): Promise<AcquireResult>;
+    /**
+     * Release a concurrent request slot
+     */
+    release(): void;
+    /**
+     * Report actual token usage after request completes
+     * Used to update token bucket
+     *
+     * @param tokens - Actual tokens used
+     */
+    reportUsage(tokens: number): void;
+    /**
+     * Get current rate limiter statistics
+     */
+    getStats(): RateLimiterStats;
+    /**
+     * Reset the rate limiter
+     */
+    reset(): void;
+    /**
+     * Check if a request can be made immediately
+     */
+    canAcquire(estimatedTokens?: number): boolean;
+}
+/**
+ * Error thrown when rate limit is exceeded and throwOnLimit is true
+ */
+export declare class RateLimitExceededError extends Error {
+    readonly estimatedWaitMs: number;
+    constructor(message: string, estimatedWaitMs: number);
+}
+/**
+ * Check if an error is a RateLimitExceededError
+ */
+export declare function isRateLimitExceededError(error: unknown): error is RateLimitExceededError;

package/dist/rate-limit/types.js

@@ -0,0 +1,22 @@
+/**
+ * Rate Limiting & Retry Types
+ *
+ * Provides types for rate limiting and automatic retry functionality.
+ */
+/**
+ * Error thrown when rate limit is exceeded and throwOnLimit is true
+ */
+export class RateLimitExceededError extends Error {
+    estimatedWaitMs;
+    constructor(message, estimatedWaitMs) {
+        super(message);
+        this.estimatedWaitMs = estimatedWaitMs;
+        this.name = 'RateLimitExceededError';
+    }
+}
+/**
+ * Check if an error is a RateLimitExceededError
+ */
+export function isRateLimitExceededError(error) {
+    return error instanceof RateLimitExceededError;
+}

package/dist/rehearsal/file-analyzer.d.ts

@@ -0,0 +1,22 @@
+/**
+ * File Rehearsal Analyzer
+ *
+ * Analyzes destructive file operations and provides impact assessment.
+ * Handles: rm, unlink, rmdir, file deletions, overwrites
+ */
+import type { RehearsalAnalyzer, RehearsalResult, RehearsalContext } from './types.js';
+/**
+ * File Rehearsal Analyzer
+ */
+export declare class FileRehearsalAnalyzer implements RehearsalAnalyzer {
+    readonly id = "file-analyzer";
+    readonly name = "File Operations Analyzer";
+    readonly category: "file";
+    readonly patterns: RegExp[];
+    canAnalyze(operation: string): boolean;
+    analyze(operation: string, context: RehearsalContext): Promise<RehearsalResult>;
+}
+/**
+ * Create a File rehearsal analyzer
+ */
+export declare function createFileAnalyzer(): FileRehearsalAnalyzer;

package/dist/rehearsal/file-analyzer.js

@@ -0,0 +1,351 @@
+/**
+ * File Rehearsal Analyzer
+ *
+ * Analyzes destructive file operations and provides impact assessment.
+ * Handles: rm, unlink, rmdir, file deletions, overwrites
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+/**
+ * Patterns for destructive file operations
+ */
+const FILE_DESTRUCTIVE_PATTERNS = [
+    // rm commands
+    /^rm\s+/i,
+    /^rm\s+-rf?\s+/i,
+    /^rm\s+-fr?\s+/i,
+    // rmdir
+    /^rmdir\s+/i,
+    // unlink (Node.js)
+    /fs\.unlink/i,
+    /fs\.rm/i,
+    /fs\.rmdir/i,
+    // Truncate operations
+    />\s*[^|]/, // redirect that truncates
+    /truncate\s+/i,
+    // Move/overwrite
+    /^mv\s+.*\s+\S+$/i, // mv can overwrite
+    /^cp\s+.*-f/i, // cp -f overwrites
+];
+/**
+ * Get file stats safely
+ */
+function getFileStats(filePath) {
+    try {
+        return fs.statSync(filePath);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Count lines in a file
+ */
+function countLines(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        return content.split('\n').length;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * Get all files in a directory recursively
+ */
+function getFilesRecursively(dirPath, maxDepth = 10) {
+    const files = [];
+    function walk(currentPath, depth) {
+        if (depth > maxDepth)
+            return;
+        try {
+            const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(currentPath, entry.name);
+                if (entry.isDirectory()) {
+                    // Skip node_modules and .git for performance
+                    if (entry.name === 'node_modules' || entry.name === '.git') {
+                        continue;
+                    }
+                    walk(fullPath, depth + 1);
+                }
+                else {
+                    files.push(fullPath);
+                }
+            }
+        }
+        catch {
+            // Ignore permission errors
+        }
+    }
+    walk(dirPath, 0);
+    return files;
+}
+/**
+ * Parse file paths from rm command
+ */
+function parseRmTargets(operation) {
+    // Tokenize the command
+    const tokens = [];
+    let current = '';
+    let inQuote = false;
+    let quoteChar = '';
+    // Remove the 'rm' prefix
+    const withoutRm = operation.replace(/^rm\s+/, '');
+    for (const char of withoutRm) {
+        if ((char === '"' || char === "'") && !inQuote) {
+            inQuote = true;
+            quoteChar = char;
+        }
+        else if (char === quoteChar && inQuote) {
+            inQuote = false;
+            quoteChar = '';
+        }
+        else if (char === ' ' && !inQuote) {
+            if (current) {
+                tokens.push(current);
+                current = '';
+            }
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current) {
+        tokens.push(current);
+    }
+    // Filter out flags (tokens starting with -)
+    const targets = tokens.filter((t) => !t.startsWith('-'));
+    return targets;
+}
+/**
+ * Expand glob patterns (basic implementation)
+ */
+function expandPath(targetPath, cwd) {
+    const absolutePath = path.isAbsolute(targetPath) ? targetPath : path.join(cwd, targetPath);
+    // If it contains wildcards, we'd need glob - for now, just return the path
+    if (targetPath.includes('*') || targetPath.includes('?')) {
+        // Basic glob support - just return warning
+        return [absolutePath];
+    }
+    return [absolutePath];
+}
+/**
+ * Analyze impact of deleting a path
+ */
+function analyzePathDeletion(targetPath, cwd) {
+    const absolutePath = path.isAbsolute(targetPath) ? targetPath : path.join(cwd, targetPath);
+    const stats = getFileStats(absolutePath);
+    if (!stats) {
+        return { files: [], totalLines: 0, totalSize: 0 };
+    }
+    const files = [];
+    let totalLines = 0;
+    let totalSize = 0;
+    if (stats.isDirectory()) {
+        const allFiles = getFilesRecursively(absolutePath);
+        for (const filePath of allFiles) {
+            const fileStats = getFileStats(filePath);
+            if (fileStats) {
+                const lines = countLines(filePath);
+                totalLines += lines;
+                totalSize += fileStats.size;
+                files.push({
+                    path: filePath,
+                    changeType: 'delete',
+                    linesAffected: lines,
+                    lastModified: fileStats.mtime,
+                    size: fileStats.size,
+                });
+            }
+        }
+    }
+    else {
+        const lines = countLines(absolutePath);
+        totalLines = lines;
+        totalSize = stats.size;
+        files.push({
+            path: absolutePath,
+            changeType: 'delete',
+            linesAffected: lines,
+            lastModified: stats.mtime,
+            size: stats.size,
+        });
+    }
+    return { files, totalLines, totalSize };
+}
+/**
+ * Format bytes to human readable
+ */
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${String(bytes)} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    if (bytes < 1024 * 1024 * 1024)
+        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}
+/**
+ * Calculate time investment based on file modification times
+ */
+function calculateTimeInvestment(files, _sessionStartTime) {
+    if (files.length === 0)
+        return undefined;
+    const now = new Date();
+    const recentFiles = files.filter((f) => {
+        if (!f.lastModified)
+            return false;
+        const hoursSinceModified = (now.getTime() - f.lastModified.getTime()) / (1000 * 60 * 60);
+        return hoursSinceModified < 24;
+    });
+    if (recentFiles.length === 0)
+        return undefined;
+    // Find the most recent modification
+    const mostRecent = recentFiles.reduce((latest, f) => {
+        if (!f.lastModified)
+            return latest;
+        if (!latest || f.lastModified > latest)
+            return f.lastModified;
+        return latest;
+    }, null);
+    if (!mostRecent)
+        return undefined;
+    const hoursSince = (now.getTime() - mostRecent.getTime()) / (1000 * 60 * 60);
+    if (hoursSince < 1) {
+        return `${String(recentFiles.length)} file(s) modified in the last hour`;
+    }
+    else if (hoursSince < 24) {
+        return `${String(recentFiles.length)} file(s) modified in the last ${String(Math.round(hoursSince))} hours`;
+    }
+    return undefined;
+}
+/**
+ * Determine severity based on impact
+ */
+function calculateSeverity(filesAffected, linesAffected, sizeBytes, isRecursive) {
+    // Critical: large recursive deletions
+    if (isRecursive && (filesAffected > 50 || linesAffected > 5000 || sizeBytes > 10 * 1024 * 1024)) {
+        return 'critical';
+    }
+    // High: significant deletions
+    if (filesAffected > 20 || linesAffected > 1000 || sizeBytes > 1024 * 1024) {
+        return 'high';
+    }
+    // Medium: moderate deletions
+    if (filesAffected > 5 || linesAffected > 100) {
+        return 'medium';
+    }
+    return 'low';
+}
+/**
+ * Determine recommendation based on analysis
+ */
+function calculateRecommendation(severity, filesExist) {
+    if (!filesExist) {
+        return 'proceed'; // Nothing to delete
+    }
+    if (severity === 'critical') {
+        return 'abort';
+    }
+    if (severity === 'high') {
+        return 'confirm';
+    }
+    if (severity === 'medium') {
+        return 'caution';
+    }
+    return 'proceed';
+}
+/**
+ * File Rehearsal Analyzer
+ */
+export class FileRehearsalAnalyzer {
+    id = 'file-analyzer';
+    name = 'File Operations Analyzer';
+    category = 'file';
+    patterns = FILE_DESTRUCTIVE_PATTERNS;
+    canAnalyze(operation) {
+        return this.patterns.some((pattern) => pattern.test(operation));
+    }
+    async analyze(operation, context) {
+        await Promise.resolve(); // Ensure async method has await
+        const startTime = Date.now();
+        const cwd = context.workingDirectory;
+        // Detect operation type
+        const isRm = /^rm\s+/i.test(operation);
+        const isRecursive = /-r/i.test(operation) || /-R/i.test(operation);
+        const isForce = /-f/i.test(operation);
+        let allFiles = [];
+        let totalLines = 0;
+        let totalSize = 0;
+        const warnings = [];
+        if (isRm) {
+            const targets = parseRmTargets(operation);
+            for (const target of targets) {
+                const expandedPaths = expandPath(target, cwd);
+                for (const targetPath of expandedPaths) {
+                    // Check for dangerous paths
+                    if (targetPath === '/' || targetPath === cwd || targetPath === process.env.HOME) {
+                        warnings.push(`⚠️ DANGER: Attempting to delete critical path: ${targetPath}`);
+                    }
+                    const analysis = analyzePathDeletion(targetPath, cwd);
+                    allFiles = [...allFiles, ...analysis.files];
+                    totalLines += analysis.totalLines;
+                    totalSize += analysis.totalSize;
+                }
+            }
+            if (isRecursive) {
+                warnings.push('Recursive deletion (-r) will remove all contents');
+            }
+            if (isForce) {
+                warnings.push('Force flag (-f) will ignore nonexistent files and skip prompts');
+            }
+            if (operation.includes('*')) {
+                warnings.push('Glob pattern (*) detected - verify targets before proceeding');
+            }
+        }
+        const timeInvestment = calculateTimeInvestment(allFiles, context.sessionStartTime);
+        const severity = calculateSeverity(allFiles.length, totalLines, totalSize, isRecursive);
+        const recommendation = calculateRecommendation(severity, allFiles.length > 0);
+        // Build summary
+        let summary;
+        if (allFiles.length === 0) {
+            summary = 'No files found to delete';
+        }
+        else if (allFiles.length === 1) {
+            summary = `Will delete 1 file (${formatBytes(totalSize)}, ${String(totalLines)} lines)`;
+        }
+        else {
+            summary = `Will delete ${String(allFiles.length)} files (${formatBytes(totalSize)}, ${String(totalLines)} lines total)`;
+        }
+        return {
+            operation,
+            category: 'file',
+            isDestructive: allFiles.length > 0,
+            isReversible: false,
+            impact: {
+                filesAffected: allFiles.length,
+                linesAffected: totalLines,
+                affectedFiles: allFiles.slice(0, 50), // Limit to first 50 for large deletions
+                timeInvestment,
+                dataSize: totalSize,
+                summary,
+            },
+            severity,
+            warnings,
+            recommendation,
+            alternatives: [
+                'mv <files> /tmp/ (move to temp instead of deleting)',
+                'ls -la <path> (list files first)',
+                'Create a backup before deleting',
+            ],
+            analysisTimeMs: Date.now() - startTime,
+        };
+    }
+}
+/**
+ * Create a File rehearsal analyzer
+ */
+export function createFileAnalyzer() {
+    return new FileRehearsalAnalyzer();
+}

package/dist/rehearsal/git-analyzer.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Git Rehearsal Analyzer
+ *
+ * Analyzes destructive git operations and provides impact assessment.
+ * Handles: git reset, git checkout --, git restore, git clean, git stash drop
+ */
+import type { RehearsalAnalyzer, RehearsalResult, RehearsalContext } from './types.js';
+/**
+ * Git Rehearsal Analyzer
+ */
+export declare class GitRehearsalAnalyzer implements RehearsalAnalyzer {
+    readonly id = "git-analyzer";
+    readonly name = "Git Operations Analyzer";
+    readonly category: "git";
+    readonly patterns: RegExp[];
+    canAnalyze(operation: string): boolean;
+    analyze(operation: string, context: RehearsalContext): Promise<RehearsalResult>;
+}
+/**
+ * Create a Git rehearsal analyzer
+ */
+export declare function createGitAnalyzer(): GitRehearsalAnalyzer;