@sudocode-ai/local-server 0.1.7 → 0.1.8

package/dist/routes/executions.js

@@ -2,50 +2,64 @@
  * Executions API routes (mapped to /api)
  *
  * Provides REST API for managing issue executions.
+ *
+ * Note: All routes require X-Project-ID header via requireProject() middleware
  */
 import { Router } from "express";
-import { ExecutionService } from "../services/execution-service.js";
-import { ExecutionLogsStore } from "../services/execution-logs-store.js";
+import { execSync } from "child_process";
+import { NormalizedEntryToAgUiAdapter } from "../execution/output/normalized-to-ag-ui-adapter.js";
+import { AgUiEventAdapter } from "../execution/output/ag-ui-adapter.js";
+import { agentRegistryService } from "../services/agent-registry.js";
+import { AgentNotFoundError, AgentNotImplementedError, AgentError, } from "../errors/agent-errors.js";
+import { WorktreeSyncService, WorktreeSyncError, WorktreeSyncErrorCode, } from "../services/worktree-sync-service.js";
+import { ExecutionChangesService } from "../services/execution-changes-service.js";
+/**
+ * Get WorktreeSyncService instance for a request
+ *
+ * @param req - Express request with project context
+ * @returns WorktreeSyncService instance
+ */
+function getWorktreeSyncService(req) {
+    const db = req.project.db;
+    const repoPath = req.project.path;
+    return new WorktreeSyncService(db, repoPath);
+}
+/**
+ * Get HTTP status code for WorktreeSyncError
+ *
+ * @param error - WorktreeSyncError instance
+ * @returns HTTP status code
+ */
+function getStatusCodeForSyncError(error) {
+    switch (error.code) {
+        case WorktreeSyncErrorCode.NO_WORKTREE:
+        case WorktreeSyncErrorCode.WORKTREE_MISSING:
+        case WorktreeSyncErrorCode.BRANCH_MISSING:
+        case WorktreeSyncErrorCode.TARGET_BRANCH_MISSING:
+        case WorktreeSyncErrorCode.EXECUTION_NOT_FOUND:
+            return 404; // Not found
+        case WorktreeSyncErrorCode.DIRTY_WORKING_TREE:
+        case WorktreeSyncErrorCode.CODE_CONFLICTS:
+        case WorktreeSyncErrorCode.NO_COMMON_BASE:
+            return 400; // Bad request (user must fix)
+        case WorktreeSyncErrorCode.MERGE_FAILED:
+        case WorktreeSyncErrorCode.JSONL_RESOLUTION_FAILED:
+        case WorktreeSyncErrorCode.DATABASE_SYNC_FAILED:
+            return 500; // Internal error
+        default:
+            return 500;
+    }
+}
 /**
  * Create executions router
  *
- * @param db - Database instance
- * @param repoPath - Path to git repository
- * @param transportManager - Optional transport manager for SSE streaming
- * @param executionService - Optional execution service instance
- * @param logsStore - Optional execution logs store instance
+ * Note: ExecutionService and ExecutionLogsStore are accessed via req.project
+ * which is injected by the requireProject() middleware
+ *
  * @returns Express router with execution endpoints
  */
-export function createExecutionsRouter(db, repoPath, transportManager, executionService, logsStore) {
+export function createExecutionsRouter() {
     const router = Router();
-    const service = executionService ||
-        new ExecutionService(db, repoPath, undefined, transportManager);
-    const store = logsStore || new ExecutionLogsStore(db);
-    /**
-     * POST /api/issues/:issueId/executions/prepare
-     *
-     * Prepare an execution - render template and show preview
-     */
-    router.post("/issues/:issueId/executions/prepare", async (req, res) => {
-        try {
-            const { issueId } = req.params;
-            const options = req.body || {};
-            const result = await service.prepareExecution(issueId, options);
-            res.json({
-                success: true,
-                data: result,
-            });
-        }
-        catch (error) {
-            console.error("[API Route] ERROR: Failed to prepare execution:", error);
-            res.status(500).json({
-                success: false,
-                data: null,
-                error_data: error instanceof Error ? error.message : String(error),
-                message: "Failed to prepare execution",
-            });
-        }
-    });
     /**
      * POST /api/issues/:issueId/executions
      *
@@ -54,7 +68,7 @@ export function createExecutionsRouter(db, repoPath, transportManager, execution
     router.post("/issues/:issueId/executions", async (req, res) => {
         try {
             const { issueId } = req.params;
-            const { config, prompt } = req.body;
+            const { config, prompt, agentType } = req.body;
             // Validate required fields
             if (!prompt) {
                 res.status(400).json({
@@ -64,7 +78,22 @@ export function createExecutionsRouter(db, repoPath, transportManager, execution
                 });
                 return;
             }
-            const execution = await service.createExecution(issueId, config || {}, prompt);
+            // Validate agentType if provided
+            if (agentType) {
+                // Check if agent exists in registry
+                if (!agentRegistryService.hasAgent(agentType)) {
+                    const availableAgents = agentRegistryService
+                        .getAvailableAgents()
+                        .map((a) => a.name);
+                    throw new AgentNotFoundError(agentType, availableAgents);
+                }
+                // Check if agent is implemented
+                if (!agentRegistryService.isAgentImplemented(agentType)) {
+                    throw new AgentNotImplementedError(agentType);
+                }
+            }
+            const execution = await req.project.executionService.createExecution(issueId, config || {}, prompt, agentType // Optional, defaults to 'claude-code' in service
+            );
             res.status(201).json({
                 success: true,
                 data: execution,
@@ -72,7 +101,39 @@ export function createExecutionsRouter(db, repoPath, transportManager, execution
         }
         catch (error) {
             console.error("[API Route] ERROR: Failed to create execution:", error);
-            // Handle specific error cases
+            // Handle agent-specific errors with enhanced error responses
+            if (error instanceof AgentNotFoundError) {
+                res.status(400).json({
+                    success: false,
+                    data: null,
+                    error: error.message,
+                    code: error.code,
+                    details: error.details,
+                });
+                return;
+            }
+            if (error instanceof AgentNotImplementedError) {
+                res.status(501).json({
+                    success: false,
+                    data: null,
+                    error: error.message,
+                    code: error.code,
+                    details: error.details,
+                });
+                return;
+            }
+            if (error instanceof AgentError) {
+                // Generic agent error (400 by default)
+                res.status(400).json({
+                    success: false,
+                    data: null,
+                    error: error.message,
+                    code: error.code,
+                    details: error.details,
+                });
+                return;
+            }
+            // Handle other errors (backwards compatibility)
             const errorMessage = error instanceof Error ? error.message : String(error);
             const statusCode = errorMessage.includes("not found") ? 404 : 500;
             res.status(statusCode).json({
@@ -91,7 +152,7 @@ export function createExecutionsRouter(db, repoPath, transportManager, execution
     router.get("/executions/:executionId", (req, res) => {
         try {
             const { executionId } = req.params;
-            const execution = service.getExecution(executionId);
+            const execution = req.project.executionService.getExecution(executionId);
             if (!execution) {
                 res.status(404).json({
                     success: false,
@@ -115,16 +176,86 @@ export function createExecutionsRouter(db, repoPath, transportManager, execution
             });
         }
     });
+    /**
+     * GET /api/executions/:executionId/chain
+     *
+     * Get execution chain (root execution + all follow-ups)
+     *
+     * Returns the full chain of executions starting from the root.
+     * If the requested execution is a follow-up, finds the root and returns the full chain.
+     * Executions are ordered chronologically (oldest first).
+     */
+    router.get("/executions/:executionId/chain", (req, res) => {
+        try {
+            const { executionId } = req.params;
+            const db = req.project.db;
+            // Get the requested execution
+            const execution = req.project.executionService.getExecution(executionId);
+            if (!execution) {
+                res.status(404).json({
+                    success: false,
+                    data: null,
+                    message: `Execution not found: ${executionId}`,
+                });
+                return;
+            }
+            // Find the root execution by traversing up parent_execution_id
+            let rootId = executionId;
+            let current = execution;
+            while (current.parent_execution_id) {
+                rootId = current.parent_execution_id;
+                const parent = req.project.executionService.getExecution(rootId);
+                if (!parent)
+                    break;
+                current = parent;
+            }
+            // Get all executions in the chain (root + all descendants)
+            // Using recursive CTE to get all descendants
+            const chain = db
+                .prepare(`
+        WITH RECURSIVE execution_chain AS (
+          -- Base case: the root execution
+          SELECT * FROM executions WHERE id = ?
+          UNION ALL
+          -- Recursive case: children of executions in the chain
+          SELECT e.* FROM executions e
+          INNER JOIN execution_chain ec ON e.parent_execution_id = ec.id
+        )
+        SELECT * FROM execution_chain
+        ORDER BY created_at ASC
+      `)
+                .all(rootId);
+            res.json({
+                success: true,
+                data: {
+                    rootId,
+                    executions: chain,
+                },
+            });
+        }
+        catch (error) {
+            console.error("Error getting execution chain:", error);
+            res.status(500).json({
+                success: false,
+                data: null,
+                error_data: error instanceof Error ? error.message : String(error),
+                message: "Failed to get execution chain",
+            });
+        }
+    });
     /**
      * GET /api/executions/:executionId/logs
      *
-     * Get raw execution logs for historical replay
+     * Get AG-UI events for historical replay
+     *
+     * Fetches NormalizedEntry logs from storage and converts them to AG-UI events on-demand.
+     * This preserves full structured data in storage while serving UI-ready events to frontend.
      */
-    router.get("/executions/:executionId/logs", (req, res) => {
+    router.get("/executions/:executionId/logs", async (req, res) => {
         try {
             const { executionId } = req.params;
             // Verify execution exists
-            const execution = service.getExecution(executionId);
+            const execution = req.project.executionService.getExecution(executionId);
             if (!execution) {
                 res.status(404).json({
                     success: false,
@@ -133,14 +264,27 @@ export function createExecutionsRouter(db, repoPath, transportManager, execution
                 });
                 return;
             }
-            // Fetch raw logs and metadata
-            const logs = store.getRawLogs(executionId);
-            const metadata = store.getLogMetadata(executionId);
+            // Fetch normalized entries from storage
+            const normalizedEntries = req.project.logsStore.getNormalizedEntries(executionId);
+            const metadata = req.project.logsStore.getLogMetadata(executionId);
+            // Convert NormalizedEntry to AG-UI events on-demand
+            const events = [];
+            // Create a temporary AG-UI adapter to collect events
+            const agUiAdapter = new AgUiEventAdapter(executionId);
+            agUiAdapter.onEvent((event) => {
+                events.push(event);
+            });
+            // Create normalized adapter to transform entries
+            const normalizedAdapter = new NormalizedEntryToAgUiAdapter(agUiAdapter);
+            // Process all normalized entries through the adapter
+            for (const entry of normalizedEntries) {
+                await normalizedAdapter.processEntry(entry);
+            }
             res.json({
                 success: true,
                 data: {
                     executionId,
-                    logs,
+                    events,
                     metadata: metadata
                         ? {
                             lineCount: metadata.line_count,
@@ -167,6 +311,40 @@ export function createExecutionsRouter(db, repoPath, transportManager, execution
             });
         }
     });
+    /**
+     * GET /api/executions/:executionId/changes
+     *
+     * Get code changes (file list + diff statistics) for an execution
+     *
+     * Calculates changes on-demand from commit SHAs. Supports:
+     * - Committed changes (commit-to-commit diff)
+     * - Uncommitted changes (working tree diff)
+     * - Unavailable states with clear error reasons
+     */
+    router.get("/executions/:executionId/changes", async (req, res) => {
+        try {
+            const { executionId } = req.params;
+            const db = req.project.db;
+            const repoPath = req.project.path;
+            // Create changes service
+            const changesService = new ExecutionChangesService(db, repoPath);
+            // Get changes
+            const result = await changesService.getChanges(executionId);
+            res.json({
+                success: true,
+                data: result,
+            });
+        }
+        catch (error) {
+            console.error("[GET /executions/:id/changes] Error:", error);
+            res.status(500).json({
+                success: false,
+                data: null,
+                error_data: error instanceof Error ? error.message : String(error),
+                message: "Failed to calculate changes",
+            });
+        }
+    });
     /**
      * GET /api/issues/:issueId/executions
      *
@@ -175,7 +353,7 @@ export function createExecutionsRouter(db, repoPath, transportManager, execution
     router.get("/issues/:issueId/executions", (req, res) => {
         try {
             const { issueId } = req.params;
-            const executions = service.listExecutions(issueId);
+            const executions = req.project.executionService.listExecutions(issueId);
             res.json({
                 success: true,
                 data: executions,
@@ -209,7 +387,7 @@ export function createExecutionsRouter(db, repoPath, transportManager, execution
                 });
                 return;
             }
-            const followUpExecution = await service.createFollowUp(executionId, feedback);
+            const followUpExecution = await req.project.executionService.createFollowUp(executionId, feedback);
             res.status(201).json({
                 success: true,
                 data: followUpExecution,
@@ -232,14 +410,14 @@ export function createExecutionsRouter(db, repoPath, transportManager, execution
         }
     });
     /**
-     * DELETE /api/executions/:executionId
+     * POST /api/executions/:executionId/cancel
      *
      * Cancel a running execution
      */
-    router.delete("/executions/:executionId", async (req, res) => {
+    router.post("/executions/:executionId/cancel", async (req, res) => {
         try {
             const { executionId } = req.params;
-            await service.cancelExecution(executionId);
+            await req.project.executionService.cancelExecution(executionId);
             res.json({
                 success: true,
                 data: { executionId },
@@ -259,6 +437,51 @@ export function createExecutionsRouter(db, repoPath, transportManager, execution
             });
         }
     });
+    /**
+     * DELETE /api/executions/:executionId
+     *
+     * Delete an execution and its entire chain (or cancel if ?cancel=true)
+     *
+     * Query parameters:
+     * - cancel: if "true", cancel the execution instead of deleting it
+     * - deleteBranch: if "true", also delete the execution's branch
+     * - deleteWorktree: if "true", also delete the execution's worktree
+     */
+    router.delete("/executions/:executionId", async (req, res) => {
+        try {
+            const { executionId } = req.params;
+            const { cancel, deleteBranch, deleteWorktree } = req.query;
+            // If cancel query param is true, cancel the execution
+            if (cancel === "true") {
+                await req.project.executionService.cancelExecution(executionId);
+                res.json({
+                    success: true,
+                    data: { executionId },
+                    message: "Execution cancelled successfully",
+                });
+                return;
+            }
+            // Otherwise, delete the execution and its chain
+            await req.project.executionService.deleteExecution(executionId, deleteBranch === "true", deleteWorktree === "true");
+            res.json({
+                success: true,
+                data: { executionId },
+                message: "Execution deleted successfully",
+            });
+        }
+        catch (error) {
+            console.error("Error deleting/cancelling execution:", error);
+            // Handle specific error cases
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const statusCode = errorMessage.includes("not found") ? 404 : 500;
+            res.status(statusCode).json({
+                success: false,
+                data: null,
+                error_data: errorMessage,
+                message: "Failed to delete/cancel execution",
+            });
+        }
+    });
     /**
      * GET /api/executions/:executionId/worktree
      *
@@ -267,7 +490,7 @@ export function createExecutionsRouter(db, repoPath, transportManager, execution
     router.get("/executions/:executionId/worktree", async (req, res) => {
         try {
             const { executionId } = req.params;
-            const exists = await service.worktreeExists(executionId);
+            const exists = await req.project.executionService.worktreeExists(executionId);
             res.json({
                 success: true,
                 data: { exists },
@@ -287,11 +510,15 @@ export function createExecutionsRouter(db, repoPath, transportManager, execution
      * DELETE /api/executions/:executionId/worktree
      *
      * Delete the worktree for an execution
+     *
+     * Query parameters:
+     * - deleteBranch: if "true", also delete the execution's branch
      */
     router.delete("/executions/:executionId/worktree", async (req, res) => {
         try {
             const { executionId } = req.params;
-            await service.deleteWorktree(executionId);
+            const { deleteBranch } = req.query;
+            await req.project.executionService.deleteWorktree(executionId, deleteBranch === "true");
             res.json({
                 success: true,
                 data: { executionId },
@@ -318,6 +545,231 @@ export function createExecutionsRouter(db, repoPath, transportManager, execution
             });
         }
     });
+    /**
+     * GET /api/executions/:executionId/sync/preview
+     *
+     * Preview sync changes and detect conflicts
+     *
+     * Returns preview of what would happen if sync is performed,
+     * including conflicts, diff, commits, and warnings.
+     */
+    router.get("/executions/:executionId/sync/preview", async (req, res) => {
+        try {
+            const { executionId } = req.params;
+            // Get worktree sync service
+            const syncService = getWorktreeSyncService(req);
+            // Preview sync
+            const preview = await syncService.previewSync(executionId);
+            res.json({
+                success: true,
+                data: preview,
+            });
+        }
+        catch (error) {
+            console.error(`Failed to preview sync for execution ${req.params.executionId}:`, error);
+            if (error instanceof WorktreeSyncError) {
+                const statusCode = getStatusCodeForSyncError(error);
+                res.status(statusCode).json({
+                    success: false,
+                    data: null,
+                    error: error.message,
+                    code: error.code,
+                });
+            }
+            else {
+                res.status(500).json({
+                    success: false,
+                    data: null,
+                    error: "Internal server error",
+                    message: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+    });
+    /**
+     * POST /api/executions/:executionId/sync/squash
+     *
+     * Perform squash sync operation
+     *
+     * Combines all worktree changes into a single commit on the target branch.
+     * Automatically resolves JSONL conflicts using merge-resolver.
+     *
+     * Request body:
+     * - commitMessage?: string - Optional custom commit message
+     */
+    router.post("/executions/:executionId/sync/squash", async (req, res) => {
+        try {
+            const { executionId } = req.params;
+            const { commitMessage } = req.body || {};
+            // Get worktree sync service
+            const syncService = getWorktreeSyncService(req);
+            // Check if squashSync method exists
+            if (typeof syncService.squashSync !== "function") {
+                res.status(501).json({
+                    success: false,
+                    data: null,
+                    error: "Squash sync not yet implemented",
+                    message: "The squashSync operation is not available yet",
+                });
+                return;
+            }
+            // Perform squash sync
+            const result = await syncService.squashSync(executionId, commitMessage);
+            res.json({
+                success: true,
+                data: result,
+            });
+        }
+        catch (error) {
+            console.error(`Failed to squash sync execution ${req.params.executionId}:`, error);
+            if (error instanceof WorktreeSyncError) {
+                const statusCode = getStatusCodeForSyncError(error);
+                res.status(statusCode).json({
+                    success: false,
+                    data: null,
+                    error: error.message,
+                    code: error.code,
+                });
+            }
+            else {
+                res.status(500).json({
+                    success: false,
+                    data: null,
+                    error: "Internal server error",
+                    message: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+    });
+    /**
+     * POST /api/executions/:executionId/commit
+     *
+     * Commit uncommitted changes for an execution
+     *
+     * Commits changes to the appropriate branch based on execution mode:
+     * - Local mode: Commits to target_branch (current branch)
+     * - Worktree mode: Commits to branch_name (temp branch) in worktree
+     *
+     * Request body:
+     * - message: string (required) - Commit message
+     */
+    router.post("/executions/:executionId/commit", async (req, res) => {
+        try {
+            const { executionId } = req.params;
+            const { message } = req.body;
+            // Validate commit message
+            if (!message || typeof message !== "string" || !message.trim()) {
+                res.status(400).json({
+                    success: false,
+                    data: null,
+                    message: "Commit message is required and must be non-empty",
+                });
+                return;
+            }
+            const db = req.project.db;
+            const repoPath = req.project.path;
+            // Load execution from database
+            const execution = db
+                .prepare("SELECT * FROM executions WHERE id = ?")
+                .get(executionId);
+            if (!execution) {
+                res.status(404).json({
+                    success: false,
+                    data: null,
+                    message: "Execution not found",
+                });
+                return;
+            }
+            // Parse files_changed
+            let filesChanged = [];
+            try {
+                if (execution.files_changed) {
+                    const parsed = typeof execution.files_changed === "string"
+                        ? JSON.parse(execution.files_changed)
+                        : execution.files_changed;
+                    filesChanged = Array.isArray(parsed) ? parsed : [parsed];
+                }
+            }
+            catch (error) {
+                console.error("Failed to parse files_changed:", error);
+            }
+            // Validate has uncommitted changes
+            if (filesChanged.length === 0) {
+                res.status(400).json({
+                    success: false,
+                    data: null,
+                    message: "No files to commit",
+                });
+                return;
+            }
+            // Determine working directory and target branch based on mode
+            const mode = execution.mode || "local";
+            const workingDir = mode === "worktree" && execution.worktree_path
+                ? execution.worktree_path
+                : repoPath;
+            const targetBranch = mode === "worktree"
+                ? execution.branch_name
+                : execution.target_branch || "main";
+            console.log(`[Commit] Execution ${executionId}: mode=${mode}, workingDir=${workingDir}, targetBranch=${targetBranch}`);
+            // Escape commit message for shell
+            const escapedMessage = message.replace(/"/g, '\\"');
+            // Execute git operations
+            try {
+                // Add files
+                const addCommand = `git add ${filesChanged.map((f) => `"${f}"`).join(" ")}`;
+                execSync(addCommand, {
+                    cwd: workingDir,
+                    encoding: "utf-8",
+                    stdio: "pipe",
+                });
+                // Commit with message
+                const commitCommand = `git commit -m "${escapedMessage}"`;
+                execSync(commitCommand, {
+                    cwd: workingDir,
+                    encoding: "utf-8",
+                    stdio: "pipe",
+                });
+                // Get commit SHA
+                const commitSha = execSync("git rev-parse HEAD", {
+                    cwd: workingDir,
+                    encoding: "utf-8",
+                    stdio: "pipe",
+                }).trim();
+                console.log(`[Commit] Successfully committed ${filesChanged.length} files: ${commitSha}`);
+                // Note: We do NOT update execution.after_commit here
+                // That field represents the state at execution completion time
+                // Manual commits after execution are tracked separately
+                res.json({
+                    success: true,
+                    data: {
+                        commitSha,
+                        filesCommitted: filesChanged.length,
+                        branch: targetBranch,
+                    },
+                    message: `Successfully committed ${filesChanged.length} file${filesChanged.length !== 1 ? "s" : ""}`,
+                });
+            }
+            catch (gitError) {
+                console.error("Git operation failed:", gitError);
+                const errorMessage = gitError instanceof Error ? gitError.message : String(gitError);
+                res.status(500).json({
+                    success: false,
+                    data: null,
+                    message: "Git commit failed",
+                    error: errorMessage,
+                });
+            }
+        }
+        catch (error) {
+            console.error(`Failed to commit for execution ${req.params.executionId}:`, error);
+            res.status(500).json({
+                success: false,
+                data: null,
+                error: "Internal server error",
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+    });
     return router;
 }
 //# sourceMappingURL=executions.js.map