@sudocode-ai/local-server 0.1.7 → 0.1.9

package/dist/services/execution-changes-service.js

@@ -0,0 +1,700 @@
+/**
+ * Execution Changes Service
+ *
+ * Calculates code changes (file list + diff statistics) from execution commits.
+ * Supports 3 scenarios:
+ * - Committed changes (commit-to-commit diff)
+ * - Uncommitted changes (working tree diff)
+ * - No changes
+ *
+ * @module services/execution-changes-service
+ */
+import { execSync } from "child_process";
+import { getExecution } from "./executions.js";
+import { existsSync } from "fs";
+/**
+ * Service for calculating code changes from execution commits
+ */
+export class ExecutionChangesService {
+    db;
+    repoPath;
+    constructor(db, repoPath) {
+        this.db = db;
+        this.repoPath = repoPath;
+    }
+    /**
+     * Get code changes for an execution
+     *
+     * For execution chains (follow-ups), automatically calculates accumulated changes
+     * from the root execution to the current execution.
+     *
+     * @param executionId - Execution ID
+     * @returns ExecutionChangesResult with both captured and current states
+     */
+    async getChanges(executionId) {
+        // 1. Load execution from database
+        const execution = getExecution(this.db, executionId);
+        if (!execution) {
+            console.log(`[ExecutionChangesService] Execution not found: ${executionId}`);
+            return {
+                available: false,
+                reason: "incomplete_execution",
+            };
+        }
+        console.log(`[ExecutionChangesService] Execution ${executionId}:`, {
+            status: execution.status,
+            before_commit: execution.before_commit,
+            after_commit: execution.after_commit,
+            parent_execution_id: execution.parent_execution_id,
+        });
+        // 2. Validate status (must have started executing)
+        // Allow running, completed, stopped, failed, cancelled - reject pending, preparing, paused
+        const validStatuses = ["running", "completed", "stopped", "failed", "cancelled"];
+        if (!validStatuses.includes(execution.status)) {
+            console.log(`[ExecutionChangesService] Execution not started: ${execution.status}`);
+            return {
+                available: false,
+                reason: "incomplete_execution",
+            };
+        }
+        // 3. Find root execution (for execution chains)
+        const rootExecution = this.getRootExecution(execution);
+        const beforeCommit = rootExecution.before_commit || execution.before_commit;
+        console.log(`[ExecutionChangesService] Root execution ${rootExecution.id}:`, {
+            before_commit: rootExecution.before_commit,
+            after_commit: rootExecution.after_commit,
+        });
+        console.log(`[ExecutionChangesService] Computed beforeCommit: ${beforeCommit}`);
+        // 4. Validate before_commit exists (required for calculating any changes)
+        if (!beforeCommit) {
+            console.log(`[ExecutionChangesService] Missing before_commit - cannot calculate changes`);
+            return {
+                available: false,
+                reason: "missing_commits",
+            };
+        }
+        // 5. Get branch and worktree information
+        const branchName = execution.branch_name;
+        const executionMode = execution.mode;
+        const worktreeExists = execution.worktree_path
+            ? existsSync(execution.worktree_path)
+            : false;
+        // 6. Check if branch exists and get current HEAD
+        // Always check the main repo for branch info (branches exist in main repo, not just worktrees)
+        let branchExists = false;
+        let currentBranchHead = null;
+        if (branchName) {
+            const branchInfo = this.getBranchInfo(branchName, this.repoPath);
+            branchExists = branchInfo.exists;
+            currentBranchHead = branchInfo.head;
+        }
+        // 7. Compute captured state (from root to current execution)
+        let captured;
+        let uncommittedSnapshot;
+        const hasCommittedChanges = beforeCommit &&
+            execution.after_commit &&
+            execution.after_commit !== beforeCommit;
+        if (hasCommittedChanges) {
+            // Captured: committed changes (requires beforeCommit from root)
+            const capturedResult = await this.getCommittedChanges(beforeCommit, execution.after_commit);
+            if (!capturedResult.available) {
+                // Preserve specific error reason (commits_not_found, etc.)
+                return capturedResult;
+            }
+            if (capturedResult.changes) {
+                captured = {
+                    files: capturedResult.changes.files,
+                    summary: capturedResult.changes.summary,
+                    commitRange: capturedResult.commitRange,
+                    uncommitted: false,
+                };
+            }
+            // Additionally check for uncommitted changes on top of committed changes
+            const uncommittedResult = await this.getUncommittedChanges(execution.worktree_path);
+            if (uncommittedResult.available && uncommittedResult.changes && uncommittedResult.changes.files.length > 0) {
+                uncommittedSnapshot = {
+                    files: uncommittedResult.changes.files,
+                    summary: uncommittedResult.changes.summary,
+                    commitRange: null,
+                    uncommitted: true,
+                };
+            }
+        }
+        else {
+            // Captured: uncommitted changes only (or no changes at completion)
+            const capturedResult = await this.getUncommittedChanges(execution.worktree_path);
+            if (!capturedResult.available) {
+                // Preserve specific error reason (worktree_deleted_with_uncommitted_changes, etc.)
+                return capturedResult;
+            }
+            if (capturedResult.changes) {
+                captured = {
+                    files: capturedResult.changes.files,
+                    summary: capturedResult.changes.summary,
+                    commitRange: null,
+                    uncommitted: true,
+                };
+            }
+        }
+        // 8. Compute current state (if branch exists and differs from captured)
+        // Requires beforeCommit to calculate diff
+        // Note: Use main repo for git operations (worktree may be deleted)
+        let current;
+        let additionalCommits = 0;
+        if (branchExists && currentBranchHead && beforeCommit) {
+            // Check if current HEAD is different from captured after_commit
+            const isDifferent = currentBranchHead !== execution.after_commit;
+            if (isDifferent && execution.after_commit) {
+                // Count commits between captured and current
+                // Always use main repo path (worktree may be deleted)
+                additionalCommits = this.countCommitsBetween(execution.after_commit, currentBranchHead, this.repoPath);
+                // Compute current changes (from root to current HEAD)
+                const currentResult = await this.getCommittedChanges(beforeCommit, currentBranchHead);
+                if (currentResult.available && currentResult.changes) {
+                    current = {
+                        files: currentResult.changes.files,
+                        summary: currentResult.changes.summary,
+                        commitRange: {
+                            before: beforeCommit,
+                            after: currentBranchHead,
+                        },
+                        uncommitted: false,
+                    };
+                }
+            }
+        }
+        // 9. Calculate commits ahead of target branch (for merge action visibility)
+        let commitsAhead = 0;
+        if (branchExists && currentBranchHead && execution.target_branch) {
+            commitsAhead = this.countCommitsAhead(execution.target_branch, currentBranchHead, this.repoPath);
+        }
+        // 10. Return result with both states
+        if (!captured) {
+            return {
+                available: false,
+                reason: "git_error",
+            };
+        }
+        return {
+            available: true,
+            captured,
+            uncommittedSnapshot,
+            current,
+            branchName,
+            branchExists,
+            worktreeExists,
+            executionMode,
+            additionalCommits,
+            commitsAhead,
+            // Legacy compatibility
+            changes: captured,
+            commitRange: captured.commitRange,
+            uncommitted: captured.uncommitted,
+        };
+    }
+    /**
+     * Get root execution by traversing parent_execution_id chain
+     *
+     * For execution chains (follow-ups), this finds the original root execution.
+     * This allows us to calculate accumulated changes from the start of the chain.
+     */
+    getRootExecution(execution) {
+        let current = execution;
+        let maxDepth = 100; // Safety limit to prevent infinite loops
+        let depth = 0;
+        while (current.parent_execution_id && depth < maxDepth) {
+            const parent = getExecution(this.db, current.parent_execution_id);
+            if (!parent) {
+                // Parent not found, return current as root
+                break;
+            }
+            current = parent;
+            depth++;
+        }
+        return current;
+    }
+    /**
+     * Get committed changes (commit-to-commit diff)
+     * Scenario A: after_commit exists and differs from before_commit
+     */
+    async getCommittedChanges(beforeCommit, afterCommit) {
+        try {
+            // Verify commits exist in repo
+            try {
+                execSync(`git cat-file -t ${beforeCommit}`, {
+                    cwd: this.repoPath,
+                    encoding: "utf-8",
+                    stdio: "pipe",
+                });
+                execSync(`git cat-file -t ${afterCommit}`, {
+                    cwd: this.repoPath,
+                    encoding: "utf-8",
+                    stdio: "pipe",
+                });
+            }
+            catch (error) {
+                return {
+                    available: false,
+                    reason: "commits_not_found",
+                };
+            }
+            // Get diff statistics
+            const files = await this.calculateDiff(beforeCommit, afterCommit, this.repoPath);
+            return {
+                available: true,
+                uncommitted: false,
+                commitRange: {
+                    before: beforeCommit,
+                    after: afterCommit,
+                },
+                changes: {
+                    files,
+                    summary: this.calculateSummary(files),
+                    commitRange: {
+                        before: beforeCommit,
+                        after: afterCommit,
+                    },
+                    uncommitted: false,
+                },
+            };
+        }
+        catch (error) {
+            console.error("[ExecutionChangesService] Error getting committed changes:", error);
+            return {
+                available: false,
+                reason: "git_error",
+            };
+        }
+    }
+    /**
+     * Get uncommitted changes (working tree diff)
+     * Scenario B: after_commit is null or equals before_commit
+     */
+    async getUncommittedChanges(worktreePath) {
+        // Determine the working directory to check
+        const workDir = worktreePath || this.repoPath;
+        // Check if worktree still exists
+        if (worktreePath && !existsSync(worktreePath)) {
+            return {
+                available: false,
+                reason: "worktree_deleted_with_uncommitted_changes",
+            };
+        }
+        try {
+            // Get uncommitted changes relative to HEAD
+            const files = await this.calculateDiff(null, null, workDir);
+            // If no files changed, return empty result
+            if (files.length === 0) {
+                return {
+                    available: true,
+                    uncommitted: true,
+                    commitRange: null,
+                    changes: {
+                        files: [],
+                        summary: {
+                            totalFiles: 0,
+                            totalAdditions: 0,
+                            totalDeletions: 0,
+                        },
+                        commitRange: null,
+                        uncommitted: true,
+                    },
+                };
+            }
+            return {
+                available: true,
+                uncommitted: true,
+                commitRange: null,
+                changes: {
+                    files,
+                    summary: this.calculateSummary(files),
+                    commitRange: null,
+                    uncommitted: true,
+                },
+            };
+        }
+        catch (error) {
+            console.error("[ExecutionChangesService] Error getting uncommitted changes:", error);
+            return {
+                available: false,
+                reason: "git_error",
+            };
+        }
+    }
+    /**
+     * Calculate diff statistics using git commands
+     *
+     * @param beforeCommit - Before commit SHA (null for uncommitted)
+     * @param afterCommit - After commit SHA (null for uncommitted)
+     * @param workDir - Working directory for git commands
+     * @returns Array of file change statistics
+     */
+    async calculateDiff(beforeCommit, afterCommit, workDir) {
+        // Build git diff command based on scenario
+        let numstatCmd;
+        let nameStatusCmd;
+        if (beforeCommit && afterCommit) {
+            // Committed changes: commit-to-commit diff
+            numstatCmd = `git diff --numstat --find-renames ${beforeCommit}..${afterCommit}`;
+            nameStatusCmd = `git diff --name-status --find-renames ${beforeCommit}..${afterCommit}`;
+        }
+        else {
+            // Uncommitted changes: working tree diff
+            numstatCmd = `git diff --numstat --find-renames HEAD`;
+            nameStatusCmd = `git diff --name-status --find-renames HEAD`;
+        }
+        // Execute git diff --numstat
+        const numstatOutput = execSync(numstatCmd, {
+            cwd: workDir,
+            encoding: "utf-8",
+            stdio: "pipe",
+        }).trim();
+        // Execute git diff --name-status
+        const nameStatusOutput = execSync(nameStatusCmd, {
+            cwd: workDir,
+            encoding: "utf-8",
+            stdio: "pipe",
+        }).trim();
+        // Parse outputs
+        const numstatData = this.parseNumstat(numstatOutput);
+        const statusData = this.parseNameStatus(nameStatusOutput);
+        // Combine numstat and status data
+        let files = this.combineFileData(numstatData, statusData);
+        // For uncommitted changes, also include untracked files
+        if (!beforeCommit && !afterCommit) {
+            const untrackedFiles = this.getUntrackedFiles(workDir);
+            files = files.concat(untrackedFiles);
+        }
+        return files;
+    }
+    /**
+     * Parse git diff --numstat output
+     *
+     * Format: "additions\tdeletions\tfilepath"
+     * Binary files: "-\t-\tfilepath"
+     */
+    parseNumstat(output) {
+        const data = new Map();
+        if (!output) {
+            return data;
+        }
+        const lines = output.split("\n");
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            const parts = line.split("\t");
+            if (parts.length < 3)
+                continue;
+            const additions = parts[0] === "-" ? 0 : parseInt(parts[0], 10);
+            const deletions = parts[1] === "-" ? 0 : parseInt(parts[1], 10);
+            const filePath = parts.slice(2).join("\t"); // Handle filenames with tabs
+            data.set(filePath, { additions, deletions });
+        }
+        return data;
+    }
+    /**
+     * Parse git diff --name-status output
+     *
+     * Format: "STATUS\tfilepath"
+     * Renamed files: "R100\toldpath\tnewpath"
+     */
+    parseNameStatus(output) {
+        const data = new Map();
+        if (!output) {
+            return data;
+        }
+        const lines = output.split("\n");
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            const parts = line.split("\t");
+            if (parts.length < 2)
+                continue;
+            const statusCode = parts[0];
+            let status;
+            if (statusCode.startsWith("A")) {
+                status = "A";
+            }
+            else if (statusCode.startsWith("M")) {
+                status = "M";
+            }
+            else if (statusCode.startsWith("D")) {
+                status = "D";
+            }
+            else if (statusCode.startsWith("R")) {
+                status = "R";
+            }
+            else {
+                // Default to modified for unknown status
+                status = "M";
+            }
+            // For renamed files, use the new path (last part)
+            const filePath = parts[parts.length - 1];
+            data.set(filePath, status);
+        }
+        return data;
+    }
+    /**
+     * Combine numstat and name-status data into FileChangeStat array
+     */
+    combineFileData(numstatData, statusData) {
+        const files = [];
+        // Iterate through all files from numstat
+        for (const [path, { additions, deletions }] of numstatData) {
+            const status = statusData.get(path) || "M"; // Default to modified
+            files.push({
+                path,
+                additions,
+                deletions,
+                status,
+            });
+        }
+        return files;
+    }
+    /**
+     * Calculate summary statistics from file changes
+     */
+    calculateSummary(files) {
+        return {
+            totalFiles: files.length,
+            totalAdditions: files.reduce((sum, file) => sum + file.additions, 0),
+            totalDeletions: files.reduce((sum, file) => sum + file.deletions, 0),
+        };
+    }
+    /**
+     * Get branch information (existence and current HEAD)
+     */
+    getBranchInfo(branchName, workDir) {
+        try {
+            // Try to get the commit SHA for the branch
+            const head = execSync(`git rev-parse ${branchName}`, {
+                cwd: workDir,
+                encoding: "utf-8",
+                stdio: "pipe",
+            }).trim();
+            return {
+                exists: true,
+                head,
+            };
+        }
+        catch (error) {
+            // Branch doesn't exist
+            return {
+                exists: false,
+                head: null,
+            };
+        }
+    }
+    /**
+     * Count commits between two commit SHAs
+     */
+    countCommitsBetween(fromCommit, toCommit, workDir) {
+        try {
+            const output = execSync(`git rev-list --count ${fromCommit}..${toCommit}`, {
+                cwd: workDir,
+                encoding: "utf-8",
+                stdio: "pipe",
+            }).trim();
+            return parseInt(output, 10) || 0;
+        }
+        catch (error) {
+            console.error("[ExecutionChangesService] Error counting commits:", error);
+            return 0;
+        }
+    }
+    /**
+     * Count commits the branch is ahead of target branch
+     * Uses merge-base to find the common ancestor
+     */
+    countCommitsAhead(targetBranch, branchHead, workDir) {
+        try {
+            // Find the merge base between target branch and the current branch
+            const mergeBase = execSync(`git merge-base ${targetBranch} ${branchHead}`, {
+                cwd: workDir,
+                encoding: "utf-8",
+                stdio: "pipe",
+            }).trim();
+            // Count commits from merge base to branch head
+            const output = execSync(`git rev-list --count ${mergeBase}..${branchHead}`, {
+                cwd: workDir,
+                encoding: "utf-8",
+                stdio: "pipe",
+            }).trim();
+            return parseInt(output, 10) || 0;
+        }
+        catch (error) {
+            console.error("[ExecutionChangesService] Error counting commits ahead:", error);
+            return 0;
+        }
+    }
+    /**
+     * Get untracked files (respecting .gitignore)
+     */
+    getUntrackedFiles(workDir) {
+        try {
+            // Get untracked files, excluding .gitignore patterns
+            const output = execSync("git ls-files --others --exclude-standard", {
+                cwd: workDir,
+                encoding: "utf-8",
+                stdio: "pipe",
+            }).trim();
+            if (!output) {
+                return [];
+            }
+            const files = [];
+            const lines = output.split("\n");
+            for (const filePath of lines) {
+                if (!filePath.trim())
+                    continue;
+                // Count lines in the file for additions
+                const fullPath = `${workDir}/${filePath}`;
+                let additions = 0;
+                try {
+                    if (existsSync(fullPath)) {
+                        const content = require("fs").readFileSync(fullPath, "utf-8");
+                        additions = content.split("\n").length;
+                    }
+                }
+                catch (error) {
+                    // If we can't read the file (binary, etc.), just set additions to 1
+                    additions = 1;
+                }
+                files.push({
+                    path: filePath,
+                    additions,
+                    deletions: 0,
+                    status: "A", // Untracked files are "Added"
+                });
+            }
+            return files;
+        }
+        catch (error) {
+            console.error("[ExecutionChangesService] Error getting untracked files:", error);
+            return [];
+        }
+    }
+    /**
+     * Get diff content for a specific file
+     *
+     * @param executionId - Execution ID
+     * @param filePath - Path to the file
+     * @returns Object with oldContent and newContent
+     */
+    async getFileDiff(executionId, filePath) {
+        try {
+            // 1. Load execution from database
+            const execution = getExecution(this.db, executionId);
+            if (!execution) {
+                return { success: false, error: "Execution not found" };
+            }
+            // 2. Find root execution for before_commit
+            const rootExecution = this.getRootExecution(execution);
+            const beforeCommit = rootExecution.before_commit || execution.before_commit;
+            const afterCommit = execution.after_commit;
+            if (!beforeCommit) {
+                return { success: false, error: "Missing before_commit" };
+            }
+            let oldContent = "";
+            let newContent = "";
+            // Normalize file path - remove leading './' if present
+            const normalizedPath = filePath.startsWith('./') ? filePath.slice(2) : filePath;
+            console.log(`[ExecutionChangesService] Getting diff for ${filePath}:`, {
+                beforeCommit,
+                afterCommit,
+                worktreePath: execution.worktree_path,
+                normalizedPath,
+            });
+            // 3. Get old content (from before_commit)
+            try {
+                const cmd = `git show ${beforeCommit}:${normalizedPath}`;
+                console.log(`[ExecutionChangesService] Running: ${cmd}`);
+                oldContent = execSync(cmd, {
+                    cwd: this.repoPath,
+                    encoding: "utf-8",
+                    stdio: "pipe",
+                    maxBuffer: 50 * 1024 * 1024, // 50MB buffer for large files
+                });
+                console.log(`[ExecutionChangesService] Old content length: ${oldContent.length}`);
+            }
+            catch (error) {
+                // File might not exist in before_commit (new file)
+                console.log(`[ExecutionChangesService] Failed to get old content:`, error instanceof Error ? error.message : error);
+                oldContent = "";
+            }
+            // 4. Get new content (depends on whether we have committed or uncommitted changes)
+            if (afterCommit && afterCommit !== beforeCommit) {
+                // Committed changes - get from after_commit
+                console.log(`[ExecutionChangesService] Fetching new content from after_commit: ${afterCommit}`);
+                try {
+                    const cmd = `git show ${afterCommit}:${normalizedPath}`;
+                    console.log(`[ExecutionChangesService] Running: ${cmd}`);
+                    newContent = execSync(cmd, {
+                        cwd: this.repoPath,
+                        encoding: "utf-8",
+                        stdio: "pipe",
+                        maxBuffer: 50 * 1024 * 1024, // 50MB buffer for large files
+                    });
+                    console.log(`[ExecutionChangesService] New content length: ${newContent.length}`);
+                }
+                catch (error) {
+                    // File might have been deleted
+                    console.log(`[ExecutionChangesService] Failed to get new content:`, error instanceof Error ? error.message : error);
+                    newContent = "";
+                }
+            }
+            else if (execution.worktree_path && existsSync(execution.worktree_path)) {
+                // Uncommitted changes - get from working tree
+                console.log(`[ExecutionChangesService] Fetching new content from worktree: ${execution.worktree_path}`);
+                try {
+                    const { readFileSync } = await import("fs");
+                    const { join } = await import("path");
+                    const fullPath = join(execution.worktree_path, normalizedPath);
+                    console.log(`[ExecutionChangesService] Checking file: ${fullPath}`);
+                    if (existsSync(fullPath)) {
+                        newContent = readFileSync(fullPath, "utf-8");
+                        console.log(`[ExecutionChangesService] New content length: ${newContent.length}`);
+                    }
+                    else {
+                        // File might have been deleted
+                        console.log(`[ExecutionChangesService] File deleted in worktree`);
+                        newContent = "";
+                    }
+                }
+                catch (error) {
+                    return { success: false, error: `Failed to read file: ${error}` };
+                }
+            }
+            else {
+                // No after_commit and no worktree - use HEAD
+                console.log(`[ExecutionChangesService] Fetching new content from HEAD`);
+                try {
+                    newContent = execSync(`git show HEAD:${normalizedPath}`, {
+                        cwd: this.repoPath,
+                        encoding: "utf-8",
+                        stdio: "pipe",
+                        maxBuffer: 50 * 1024 * 1024, // 50MB buffer for large files
+                    });
+                    console.log(`[ExecutionChangesService] New content length: ${newContent.length}`);
+                }
+                catch (error) {
+                    console.log(`[ExecutionChangesService] File deleted at HEAD`);
+                    newContent = "";
+                }
+            }
+            console.log(`[ExecutionChangesService] Returning diff - oldContent: ${oldContent.length} chars, newContent: ${newContent.length} chars`);
+            return {
+                success: true,
+                oldContent,
+                newContent,
+            };
+        }
+        catch (error) {
+            console.error("[ExecutionChangesService] Error getting file diff:", error);
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+}
+//# sourceMappingURL=execution-changes-service.js.map