@compilr-dev/agents 0.0.1

package/dist/rehearsal/git-analyzer.js

@@ -0,0 +1,472 @@
+/**
+ * Git Rehearsal Analyzer
+ *
+ * Analyzes destructive git operations and provides impact assessment.
+ * Handles: git reset, git checkout --, git restore, git clean, git stash drop
+ */
+import { execSync } from 'node:child_process';
+/**
+ * Patterns for destructive git operations
+ */
+const GIT_DESTRUCTIVE_PATTERNS = [
+    // git reset (all forms)
+    /^git\s+reset\s+(--hard|--mixed|--soft)?\s*/i,
+    // git checkout -- (discard changes)
+    /^git\s+checkout\s+--\s*/i,
+    /^git\s+checkout\s+\.\s*$/i,
+    /^git\s+checkout\s+HEAD\s+--\s*/i,
+    // git restore (discard changes)
+    /^git\s+restore\s+/i,
+    // git clean (remove untracked)
+    /^git\s+clean\s+/i,
+    // git stash drop
+    /^git\s+stash\s+drop/i,
+    // git branch -D (force delete)
+    /^git\s+branch\s+-D\s+/i,
+    // git push --force
+    /^git\s+push\s+.*--force/i,
+    /^git\s+push\s+-f\s+/i,
+];
+/**
+ * Execute a git command and return output
+ */
+function execGit(command, cwd) {
+    try {
+        return execSync(command, {
+            cwd,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Check if directory is a git repository
+ */
+function isGitRepo(cwd) {
+    try {
+        execSync('git rev-parse --git-dir', {
+            cwd,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get list of modified files with their status
+ */
+function getModifiedFiles(cwd) {
+    const output = execGit('git status --porcelain', cwd);
+    if (!output)
+        return [];
+    const files = [];
+    for (const line of output.split('\n')) {
+        if (!line.trim())
+            continue;
+        const _status = line.substring(0, 2); // Status prefix (e.g., "M ", "D ", "??")
+        const filePath = line.substring(3).trim();
+        files.push({
+            path: filePath,
+            changeType: 'reset', // For git operations, changes would be reset
+            hasUncommittedChanges: true,
+        });
+    }
+    return files;
+}
+/**
+ * Get diff stats for modified files
+ */
+function getDiffStats(cwd) {
+    const output = execGit('git diff --stat --numstat', cwd);
+    if (!output)
+        return { files: 0, insertions: 0, deletions: 0 };
+    let insertions = 0;
+    let deletions = 0;
+    let files = 0;
+    for (const line of output.split('\n')) {
+        const match = line.match(/^(\d+)\s+(\d+)\s+/);
+        if (match) {
+            insertions += parseInt(match[1], 10);
+            deletions += parseInt(match[2], 10);
+            files++;
+        }
+    }
+    return { files, insertions, deletions };
+}
+/**
+ * Get staged diff stats
+ */
+function getStagedDiffStats(cwd) {
+    const output = execGit('git diff --cached --stat --numstat', cwd);
+    if (!output)
+        return { files: 0, insertions: 0, deletions: 0 };
+    let insertions = 0;
+    let deletions = 0;
+    let files = 0;
+    for (const line of output.split('\n')) {
+        const match = line.match(/^(\d+)\s+(\d+)\s+/);
+        if (match) {
+            insertions += parseInt(match[1], 10);
+            deletions += parseInt(match[2], 10);
+            files++;
+        }
+    }
+    return { files, insertions, deletions };
+}
+/**
+ * Get untracked files that would be affected by git clean
+ */
+function getUntrackedFiles(cwd) {
+    const output = execGit('git clean -n -d', cwd);
+    if (!output)
+        return [];
+    const files = [];
+    for (const line of output.split('\n')) {
+        const match = line.match(/^Would remove (.+)$/);
+        if (match) {
+            files.push({
+                path: match[1],
+                changeType: 'delete',
+                hasUncommittedChanges: false,
+            });
+        }
+    }
+    return files;
+}
+/**
+ * Calculate time since last commit
+ */
+function getTimeSinceLastCommit(cwd) {
+    const output = execGit('git log -1 --format=%cr', cwd);
+    return output || undefined;
+}
+/**
+ * Determine severity based on impact
+ */
+function calculateSeverity(filesAffected, linesAffected, hasUncommittedChanges) {
+    if (!hasUncommittedChanges && filesAffected === 0) {
+        return 'low';
+    }
+    if (linesAffected > 500 || filesAffected > 20) {
+        return 'critical';
+    }
+    if (linesAffected > 100 || filesAffected > 10) {
+        return 'high';
+    }
+    if (linesAffected > 20 || filesAffected > 3) {
+        return 'medium';
+    }
+    return 'low';
+}
+/**
+ * Determine recommendation based on analysis
+ */
+function calculateRecommendation(severity, isReversible) {
+    if (severity === 'critical') {
+        return isReversible ? 'confirm' : 'abort';
+    }
+    if (severity === 'high') {
+        return 'confirm';
+    }
+    if (severity === 'medium') {
+        return 'caution';
+    }
+    return 'proceed';
+}
+/**
+ * Analyze git reset command
+ */
+async function analyzeGitReset(operation, context) {
+    await Promise.resolve(); // Ensure async function has await
+    const cwd = context.workingDirectory;
+    const isHard = operation.includes('--hard');
+    const isMixed = operation.includes('--mixed') || (!isHard && !operation.includes('--soft'));
+    const modifiedFiles = getModifiedFiles(cwd);
+    const diffStats = getDiffStats(cwd);
+    const stagedStats = getStagedDiffStats(cwd);
+    const totalLines = diffStats.insertions + diffStats.deletions + stagedStats.insertions + stagedStats.deletions;
+    const warnings = [];
+    if (isHard) {
+        warnings.push('--hard will permanently discard all uncommitted changes');
+        if (totalLines > 100) {
+            warnings.push(`You will lose ${String(totalLines)} lines of changes`);
+        }
+    }
+    if (isMixed && stagedStats.files > 0) {
+        warnings.push(`${String(stagedStats.files)} staged files will be unstaged`);
+    }
+    const timeSinceCommit = getTimeSinceLastCommit(cwd);
+    const timeInvestment = timeSinceCommit
+        ? `Changes made since last commit (${timeSinceCommit})`
+        : undefined;
+    return {
+        isDestructive: isHard,
+        isReversible: !isHard, // soft and mixed are reversible
+        impact: {
+            filesAffected: modifiedFiles.length,
+            linesAffected: totalLines,
+            affectedFiles: modifiedFiles,
+            timeInvestment,
+            summary: isHard
+                ? `Will discard ${String(modifiedFiles.length)} modified files (${String(totalLines)} lines of changes)`
+                : `Will unstage ${String(stagedStats.files)} files`,
+        },
+        warnings,
+        alternatives: isHard
+            ? ['git stash (save changes for later)', 'git commit (save changes permanently)']
+            : undefined,
+    };
+}
+/**
+ * Analyze git checkout -- or git restore
+ */
+async function analyzeGitDiscard(operation, context) {
+    await Promise.resolve(); // Ensure async function has await
+    const cwd = context.workingDirectory;
+    // Check if specific files are targeted
+    const filePattern = operation.match(/(?:checkout\s+--|restore\s+(?:--staged\s+)?)\s*(.+)$/i);
+    const targetPath = filePattern?.[1]?.trim() || '.';
+    let affectedFiles;
+    let diffStats;
+    if (targetPath === '.' || targetPath === '*') {
+        // All files
+        affectedFiles = getModifiedFiles(cwd);
+        diffStats = getDiffStats(cwd);
+    }
+    else {
+        // Specific file(s)
+        const output = execGit(`git diff --numstat -- "${targetPath}"`, cwd);
+        affectedFiles = [];
+        diffStats = { files: 0, insertions: 0, deletions: 0 };
+        if (output) {
+            for (const line of output.split('\n')) {
+                const match = line.match(/^(\d+)\s+(\d+)\s+(.+)$/);
+                if (match) {
+                    diffStats.insertions += parseInt(match[1], 10);
+                    diffStats.deletions += parseInt(match[2], 10);
+                    diffStats.files++;
+                    affectedFiles.push({
+                        path: match[3],
+                        changeType: 'reset',
+                        hasUncommittedChanges: true,
+                    });
+                }
+            }
+        }
+    }
+    const totalLines = diffStats.insertions + diffStats.deletions;
+    const warnings = [];
+    if (affectedFiles.length > 0) {
+        warnings.push('This will permanently discard uncommitted changes');
+    }
+    if (totalLines > 50) {
+        warnings.push(`${String(totalLines)} lines of changes will be lost`);
+    }
+    return {
+        isDestructive: affectedFiles.length > 0,
+        isReversible: false,
+        impact: {
+            filesAffected: affectedFiles.length,
+            linesAffected: totalLines,
+            affectedFiles,
+            summary: affectedFiles.length > 0
+                ? `Will discard changes in ${String(affectedFiles.length)} file(s) (${String(totalLines)} lines)`
+                : 'No changes to discard',
+        },
+        warnings,
+        alternatives: ['git stash (save changes for later)', 'git diff (review changes first)'],
+    };
+}
+/**
+ * Analyze git clean command
+ */
+async function analyzeGitClean(operation, context) {
+    await Promise.resolve(); // Ensure async function has await
+    const cwd = context.workingDirectory;
+    const untrackedFiles = getUntrackedFiles(cwd);
+    const warnings = [];
+    if (untrackedFiles.length > 0) {
+        warnings.push('This will permanently delete untracked files');
+    }
+    if (operation.includes('-x')) {
+        warnings.push('Including ignored files (from .gitignore)');
+    }
+    if (operation.includes('-d')) {
+        warnings.push('Including untracked directories');
+    }
+    return {
+        isDestructive: untrackedFiles.length > 0,
+        isReversible: false,
+        impact: {
+            filesAffected: untrackedFiles.length,
+            linesAffected: 0,
+            affectedFiles: untrackedFiles,
+            summary: untrackedFiles.length > 0
+                ? `Will delete ${String(untrackedFiles.length)} untracked file(s)`
+                : 'No untracked files to remove',
+        },
+        warnings,
+        alternatives: ['git clean -n (preview what would be deleted)'],
+    };
+}
+/**
+ * Analyze git stash drop
+ */
+async function analyzeGitStashDrop(operation, context) {
+    await Promise.resolve(); // Ensure async function has await
+    const cwd = context.workingDirectory;
+    // Get stash info
+    const stashMatch = operation.match(/stash@\{(\d+)\}/);
+    const stashIndex = stashMatch ? stashMatch[1] : '0';
+    const stashInfo = execGit(`git stash show stash@{${stashIndex}} --stat`, cwd);
+    const stashMessage = execGit(`git stash list | head -${String(parseInt(stashIndex, 10) + 1)} | tail -1`, cwd);
+    let filesAffected = 0;
+    if (stashInfo) {
+        const match = stashInfo.match(/(\d+) files? changed/);
+        filesAffected = match ? parseInt(match[1], 10) : 0;
+    }
+    return {
+        isDestructive: true,
+        isReversible: false,
+        impact: {
+            filesAffected,
+            linesAffected: 0,
+            affectedFiles: [],
+            summary: stashMessage
+                ? `Will drop stash: ${stashMessage}`
+                : `Will drop stash@{${stashIndex}}`,
+        },
+        warnings: ['Dropped stashes cannot be recovered'],
+        alternatives: [
+            'git stash apply (apply without dropping)',
+            'git stash branch (create branch from stash)',
+        ],
+    };
+}
+/**
+ * Analyze git push --force
+ */
+async function analyzeGitForcePush(_operation, context) {
+    await Promise.resolve(); // Ensure async function has await
+    const cwd = context.workingDirectory;
+    const currentBranch = execGit('git rev-parse --abbrev-ref HEAD', cwd);
+    const warnings = [
+        'Force push will overwrite remote history',
+        'Other collaborators may lose their work',
+    ];
+    if (currentBranch === 'main' || currentBranch === 'master') {
+        warnings.unshift('⚠️ DANGER: Force pushing to main/master branch!');
+    }
+    return {
+        isDestructive: true,
+        isReversible: false, // Technically recoverable with reflog, but practically destructive
+        impact: {
+            filesAffected: 0,
+            linesAffected: 0,
+            affectedFiles: [],
+            summary: `Will force push to remote, overwriting history on ${currentBranch}`,
+        },
+        warnings,
+        alternatives: [
+            'git push --force-with-lease (safer, fails if remote has new commits)',
+            'git pull --rebase && git push (sync with remote first)',
+        ],
+    };
+}
+/**
+ * Git Rehearsal Analyzer
+ */
+export class GitRehearsalAnalyzer {
+    id = 'git-analyzer';
+    name = 'Git Operations Analyzer';
+    category = 'git';
+    patterns = GIT_DESTRUCTIVE_PATTERNS;
+    canAnalyze(operation) {
+        return this.patterns.some((pattern) => pattern.test(operation));
+    }
+    async analyze(operation, context) {
+        const startTime = Date.now();
+        const cwd = context.workingDirectory;
+        // Check if we're in a git repo
+        if (!isGitRepo(cwd)) {
+            return {
+                operation,
+                category: 'git',
+                isDestructive: false,
+                isReversible: true,
+                impact: {
+                    filesAffected: 0,
+                    linesAffected: 0,
+                    affectedFiles: [],
+                    summary: 'Not a git repository',
+                },
+                severity: 'low',
+                warnings: ['Not in a git repository - command will fail'],
+                recommendation: 'abort',
+                analysisTimeMs: Date.now() - startTime,
+            };
+        }
+        // Determine which analysis to perform
+        let partialResult;
+        if (/git\s+reset/i.test(operation)) {
+            partialResult = await analyzeGitReset(operation, context);
+        }
+        else if (/git\s+(checkout\s+--|restore)/i.test(operation)) {
+            partialResult = await analyzeGitDiscard(operation, context);
+        }
+        else if (/git\s+clean/i.test(operation)) {
+            partialResult = await analyzeGitClean(operation, context);
+        }
+        else if (/git\s+stash\s+drop/i.test(operation)) {
+            partialResult = await analyzeGitStashDrop(operation, context);
+        }
+        else if (/git\s+push\s+.*--force|-f/i.test(operation)) {
+            partialResult = await analyzeGitForcePush(operation, context);
+        }
+        else {
+            // Generic destructive git operation
+            partialResult = {
+                isDestructive: true,
+                isReversible: false,
+                impact: {
+                    filesAffected: 0,
+                    linesAffected: 0,
+                    affectedFiles: [],
+                    summary: 'Potentially destructive git operation',
+                },
+                warnings: ['This git operation may cause data loss'],
+            };
+        }
+        const severity = calculateSeverity(partialResult.impact?.filesAffected ?? 0, partialResult.impact?.linesAffected ?? 0, partialResult.isDestructive ?? false);
+        const recommendation = calculateRecommendation(severity, partialResult.isReversible ?? false);
+        return {
+            operation,
+            category: 'git',
+            isDestructive: partialResult.isDestructive ?? false,
+            isReversible: partialResult.isReversible ?? false,
+            impact: partialResult.impact ?? {
+                filesAffected: 0,
+                linesAffected: 0,
+                affectedFiles: [],
+                summary: 'Unknown impact',
+            },
+            severity,
+            warnings: partialResult.warnings ?? [],
+            recommendation,
+            alternatives: partialResult.alternatives,
+            analysisTimeMs: Date.now() - startTime,
+        };
+    }
+}
+/**
+ * Create a Git rehearsal analyzer
+ */
+export function createGitAnalyzer() {
+    return new GitRehearsalAnalyzer();
+}

package/dist/rehearsal/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Rehearsal System
+ *
+ * Provides impact analysis for destructive operations before execution.
+ * This is a novel safety feature that goes beyond simple dry-run by
+ * actually analyzing what would be affected.
+ *
+ * @example
+ * ```typescript
+ * import { RehearsalManager } from '@compilr-dev/agents';
+ *
+ * const rehearsal = new RehearsalManager({
+ *   workingDirectory: '/path/to/project',
+ * });
+ *
+ * // Before executing a destructive command
+ * const result = await rehearsal.rehearse('git reset --hard HEAD~1');
+ *
+ * console.log(result.impact.summary);
+ * // "Will discard 5 modified files (127 lines of changes)"
+ *
+ * console.log(result.warnings);
+ * // ["--hard will permanently discard all uncommitted changes"]
+ *
+ * if (result.recommendation === 'abort') {
+ *   console.log('Operation too dangerous!');
+ * } else if (result.recommendation === 'confirm') {
+ *   // Ask user for confirmation
+ * }
+ * ```
+ */
+export type { ImpactSeverity, RehearsalRecommendation, OperationCategory, AffectedFile, RehearsalImpact, RehearsalResult, RehearsalContext, RehearsalAnalyzer, RehearsalManagerOptions, RehearsalEventType, RehearsalEvent, RehearsalEventHandler, } from './types.js';
+export { RehearsalManager, createRehearsalManager } from './manager.js';
+export { GitRehearsalAnalyzer, createGitAnalyzer } from './git-analyzer.js';
+export { FileRehearsalAnalyzer, createFileAnalyzer } from './file-analyzer.js';

package/dist/rehearsal/index.js

@@ -0,0 +1,36 @@
+/**
+ * Rehearsal System
+ *
+ * Provides impact analysis for destructive operations before execution.
+ * This is a novel safety feature that goes beyond simple dry-run by
+ * actually analyzing what would be affected.
+ *
+ * @example
+ * ```typescript
+ * import { RehearsalManager } from '@compilr-dev/agents';
+ *
+ * const rehearsal = new RehearsalManager({
+ *   workingDirectory: '/path/to/project',
+ * });
+ *
+ * // Before executing a destructive command
+ * const result = await rehearsal.rehearse('git reset --hard HEAD~1');
+ *
+ * console.log(result.impact.summary);
+ * // "Will discard 5 modified files (127 lines of changes)"
+ *
+ * console.log(result.warnings);
+ * // ["--hard will permanently discard all uncommitted changes"]
+ *
+ * if (result.recommendation === 'abort') {
+ *   console.log('Operation too dangerous!');
+ * } else if (result.recommendation === 'confirm') {
+ *   // Ask user for confirmation
+ * }
+ * ```
+ */
+// Manager
+export { RehearsalManager, createRehearsalManager } from './manager.js';
+// Built-in analyzers
+export { GitRehearsalAnalyzer, createGitAnalyzer } from './git-analyzer.js';
+export { FileRehearsalAnalyzer, createFileAnalyzer } from './file-analyzer.js';

package/dist/rehearsal/manager.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Rehearsal Manager
+ *
+ * Coordinates rehearsal analyzers to provide impact analysis
+ * for destructive operations before they are executed.
+ */
+import type { RehearsalAnalyzer, RehearsalResult, RehearsalManagerOptions, RehearsalEventHandler } from './types.js';
+/**
+ * RehearsalManager - Coordinates impact analysis for destructive operations
+ *
+ * @example
+ * ```typescript
+ * const manager = new RehearsalManager({
+ *   workingDirectory: '/path/to/project',
+ * });
+ *
+ * // Analyze before executing
+ * const result = await manager.rehearse('rm -rf node_modules');
+ *
+ * if (result.recommendation === 'abort') {
+ *   console.log('Operation too dangerous:', result.warnings);
+ * } else if (result.recommendation === 'confirm') {
+ *   const confirmed = await askUser(result.impact.summary);
+ *   if (confirmed) {
+ *     // Execute the operation
+ *   }
+ * }
+ * ```
+ */
+export declare class RehearsalManager {
+    private readonly analyzers;
+    private readonly workingDirectory;
+    private readonly warningThreshold;
+    private readonly sessionStartTime;
+    private readonly sessionModifiedFiles;
+    private readonly trackSessionFiles;
+    private eventHandler?;
+    constructor(options?: RehearsalManagerOptions);
+    /**
+     * Register an analyzer
+     */
+    registerAnalyzer(analyzer: RehearsalAnalyzer): this;
+    /**
+     * Unregister an analyzer
+     */
+    unregisterAnalyzer(id: string): boolean;
+    /**
+     * Get all registered analyzers
+     */
+    getAnalyzers(): RehearsalAnalyzer[];
+    /**
+     * Set event handler
+     */
+    onEvent(handler: RehearsalEventHandler): this;
+    /**
+     * Emit an event
+     */
+    private emit;
+    /**
+     * Track a file as modified in this session
+     */
+    trackFileModification(filePath: string): void;
+    /**
+     * Get files modified in this session
+     */
+    getSessionModifiedFiles(): string[];
+    /**
+     * Check if an operation is potentially destructive
+     */
+    isDestructive(operation: string): boolean;
+    /**
+     * Find the appropriate analyzer for an operation
+     */
+    findAnalyzer(operation: string): RehearsalAnalyzer | undefined;
+    /**
+     * Rehearse an operation - analyze its impact before execution
+     *
+     * @param operation - The command or operation to analyze
+     * @returns Impact analysis result
+     */
+    rehearse(operation: string): Promise<RehearsalResult>;
+    /**
+     * Rehearse multiple operations
+     */
+    rehearseAll(operations: string[]): Promise<RehearsalResult[]>;
+    /**
+     * Check if an operation should proceed based on rehearsal
+     *
+     * @returns true if safe to proceed, false if should abort
+     */
+    shouldProceed(operation: string): Promise<boolean>;
+    /**
+     * Get a formatted summary of a rehearsal result
+     */
+    formatResult(result: RehearsalResult): string;
+}
+/**
+ * Create a RehearsalManager with default configuration
+ */
+export declare function createRehearsalManager(options?: RehearsalManagerOptions): RehearsalManager;