@gokulvenkatareddy/cortex 0.1.7

package/apps/octogent/apps/api/src/terminalRuntime/gitOperations.ts

@@ -0,0 +1,341 @@
+import type {
+  GitClient,
+  PersistedTerminal,
+  TentacleGitStatusSnapshot,
+  TentaclePullRequestSnapshot,
+} from "./types";
+import { RuntimeInputError } from "./types";
+import type { createWorktreeManager } from "./worktreeManager";
+
+type WorktreeManager = ReturnType<typeof createWorktreeManager>;
+
+export const createGitOperations = (deps: {
+  terminals: Map<string, PersistedTerminal>;
+  worktreeManager: WorktreeManager;
+  gitClient: GitClient;
+}) => {
+  const { terminals, worktreeManager, gitClient } = deps;
+
+  const resolveWorktreeTentacleContext = (
+    tentacleId: string,
+  ): { terminal: PersistedTerminal; workspaceCwd: string } | null => {
+    // Find any terminal belonging to this tentacle
+    let terminal: PersistedTerminal | undefined;
+    for (const t of terminals.values()) {
+      if (t.tentacleId === tentacleId) {
+        terminal = t;
+        break;
+      }
+    }
+    if (!terminal) {
+      return null;
+    }
+
+    if (terminal.workspaceMode !== "worktree") {
+      throw new RuntimeInputError(
+        "Git lifecycle actions are only available for worktree terminals.",
+      );
+    }
+
+    return {
+      terminal,
+      workspaceCwd: worktreeManager.getTentacleWorkspaceCwd(
+        terminal.worktreeId ?? terminal.tentacleId,
+      ),
+    };
+  };
+
+  const readWorktreeGitStatus = (
+    tentacleId: string,
+    terminal: PersistedTerminal,
+    workspaceCwd: string,
+  ): TentacleGitStatusSnapshot => {
+    try {
+      const status = gitClient.readWorktreeStatus({ cwd: workspaceCwd });
+      return {
+        tentacleId,
+        workspaceMode: terminal.workspaceMode,
+        branchName: status.branchName,
+        upstreamBranchName: status.upstreamBranchName,
+        isDirty: status.isDirty,
+        aheadCount: status.aheadCount,
+        behindCount: status.behindCount,
+        insertedLineCount: status.insertedLineCount,
+        deletedLineCount: status.deletedLineCount,
+        hasConflicts: status.hasConflicts,
+        changedFiles: [...status.changedFiles],
+        defaultBaseBranchName: status.defaultBaseBranchName,
+      };
+    } catch (error) {
+      throw new RuntimeInputError(
+        `Unable to read git status for ${tentacleId}: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+      );
+    }
+  };
+
+  const toPullRequestStatus = (state: "OPEN" | "MERGED" | "CLOSED") =>
+    state === "OPEN" ? "open" : state === "MERGED" ? "merged" : "closed";
+
+  const emptyPullRequestSnapshot = (
+    tentacleId: string,
+    terminal: PersistedTerminal,
+  ): TentaclePullRequestSnapshot => ({
+    tentacleId,
+    workspaceMode: terminal.workspaceMode,
+    status: "none",
+    number: null,
+    url: null,
+    title: null,
+    baseRef: null,
+    headRef: null,
+    isDraft: null,
+    mergeable: null,
+    mergeStateStatus: null,
+  });
+
+  const readWorktreePullRequest = (
+    tentacleId: string,
+    terminal: PersistedTerminal,
+    workspaceCwd: string,
+  ): TentaclePullRequestSnapshot => {
+    try {
+      const pullRequest = gitClient.readCurrentBranchPullRequest({ cwd: workspaceCwd });
+      if (!pullRequest) {
+        return emptyPullRequestSnapshot(tentacleId, terminal);
+      }
+
+      return {
+        tentacleId,
+        workspaceMode: terminal.workspaceMode,
+        status: toPullRequestStatus(pullRequest.state),
+        number: pullRequest.number,
+        url: pullRequest.url,
+        title: pullRequest.title,
+        baseRef: pullRequest.baseRef,
+        headRef: pullRequest.headRef,
+        isDraft: pullRequest.isDraft,
+        mergeable: pullRequest.mergeable,
+        mergeStateStatus: pullRequest.mergeStateStatus,
+      };
+    } catch (error) {
+      throw new RuntimeInputError(
+        `Unable to read pull request for ${tentacleId}: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+      );
+    }
+  };
+
+  return {
+    readTentacleGitStatus(tentacleId: string): TentacleGitStatusSnapshot | null {
+      const context = resolveWorktreeTentacleContext(tentacleId);
+      if (!context) {
+        return null;
+      }
+
+      return readWorktreeGitStatus(tentacleId, context.terminal, context.workspaceCwd);
+    },
+
+    commitTentacleWorktree(tentacleId: string, message: string): TentacleGitStatusSnapshot | null {
+      const context = resolveWorktreeTentacleContext(tentacleId);
+      if (!context) {
+        return null;
+      }
+
+      const trimmedMessage = message.trim();
+      if (trimmedMessage.length === 0) {
+        throw new RuntimeInputError("Commit message cannot be empty.");
+      }
+
+      try {
+        gitClient.commitAll({
+          cwd: context.workspaceCwd,
+          message: trimmedMessage,
+        });
+      } catch (error) {
+        throw new RuntimeInputError(
+          `Unable to commit ${tentacleId}: ${
+            error instanceof Error ? error.message : String(error)
+          }`,
+        );
+      }
+
+      return readWorktreeGitStatus(tentacleId, context.terminal, context.workspaceCwd);
+    },
+
+    pushTentacleWorktree(tentacleId: string): TentacleGitStatusSnapshot | null {
+      const context = resolveWorktreeTentacleContext(tentacleId);
+      if (!context) {
+        return null;
+      }
+
+      try {
+        gitClient.pushCurrentBranch({
+          cwd: context.workspaceCwd,
+        });
+      } catch (error) {
+        throw new RuntimeInputError(
+          `Unable to push ${tentacleId}: ${error instanceof Error ? error.message : String(error)}`,
+        );
+      }
+
+      return readWorktreeGitStatus(tentacleId, context.terminal, context.workspaceCwd);
+    },
+
+    syncTentacleWorktree(tentacleId: string, baseRef?: string): TentacleGitStatusSnapshot | null {
+      const context = resolveWorktreeTentacleContext(tentacleId);
+      if (!context) {
+        return null;
+      }
+
+      const statusBeforeSync = readWorktreeGitStatus(
+        tentacleId,
+        context.terminal,
+        context.workspaceCwd,
+      );
+      if (statusBeforeSync.isDirty) {
+        throw new RuntimeInputError(
+          "Sync requires a clean worktree. Commit or stash changes first.",
+        );
+      }
+      if (statusBeforeSync.hasConflicts) {
+        throw new RuntimeInputError("Resolve git conflicts before syncing with base.");
+      }
+
+      const normalizedBaseRef = baseRef?.trim();
+      const effectiveBaseRef =
+        normalizedBaseRef && normalizedBaseRef.length > 0
+          ? normalizedBaseRef
+          : (statusBeforeSync.defaultBaseBranchName ?? "main");
+
+      try {
+        gitClient.syncWithBase({
+          cwd: context.workspaceCwd,
+          baseRef: effectiveBaseRef,
+        });
+      } catch (error) {
+        throw new RuntimeInputError(
+          `Unable to sync ${tentacleId}: ${error instanceof Error ? error.message : String(error)}`,
+        );
+      }
+
+      return readWorktreeGitStatus(tentacleId, context.terminal, context.workspaceCwd);
+    },
+
+    readTentaclePullRequest(tentacleId: string): TentaclePullRequestSnapshot | null {
+      const context = resolveWorktreeTentacleContext(tentacleId);
+      if (!context) {
+        return null;
+      }
+
+      return readWorktreePullRequest(tentacleId, context.terminal, context.workspaceCwd);
+    },
+
+    createTentaclePullRequest(
+      tentacleId: string,
+      input: { title: string; body?: string; baseRef?: string },
+    ): TentaclePullRequestSnapshot | null {
+      const context = resolveWorktreeTentacleContext(tentacleId);
+      if (!context) {
+        return null;
+      }
+
+      const title = input.title.trim();
+      if (title.length === 0) {
+        throw new RuntimeInputError("Pull request title cannot be empty.");
+      }
+
+      const existingPullRequest = readWorktreePullRequest(
+        tentacleId,
+        context.terminal,
+        context.workspaceCwd,
+      );
+      if (existingPullRequest.status === "open") {
+        throw new RuntimeInputError("An open pull request already exists for this branch.");
+      }
+
+      const status = readWorktreeGitStatus(tentacleId, context.terminal, context.workspaceCwd);
+      if (status.hasConflicts) {
+        throw new RuntimeInputError("Resolve git conflicts before creating a pull request.");
+      }
+
+      const normalizedBaseRef = input.baseRef?.trim();
+      const effectiveBaseRef =
+        normalizedBaseRef && normalizedBaseRef.length > 0
+          ? normalizedBaseRef
+          : (status.defaultBaseBranchName ?? "main");
+
+      try {
+        const pullRequest = gitClient.createPullRequest({
+          cwd: context.workspaceCwd,
+          title,
+          body: input.body ?? "",
+          baseRef: effectiveBaseRef,
+          headRef: status.branchName,
+        });
+        if (!pullRequest) {
+          return readWorktreePullRequest(tentacleId, context.terminal, context.workspaceCwd);
+        }
+
+        return {
+          tentacleId,
+          workspaceMode: context.terminal.workspaceMode,
+          status: toPullRequestStatus(pullRequest.state),
+          number: pullRequest.number,
+          url: pullRequest.url,
+          title: pullRequest.title,
+          baseRef: pullRequest.baseRef,
+          headRef: pullRequest.headRef,
+          isDraft: pullRequest.isDraft,
+          mergeable: pullRequest.mergeable,
+          mergeStateStatus: pullRequest.mergeStateStatus,
+        };
+      } catch (error) {
+        throw new RuntimeInputError(
+          `Unable to create pull request for ${tentacleId}: ${
+            error instanceof Error ? error.message : String(error)
+          }`,
+        );
+      }
+    },
+
+    mergeTentaclePullRequest(tentacleId: string): TentaclePullRequestSnapshot | null {
+      const context = resolveWorktreeTentacleContext(tentacleId);
+      if (!context) {
+        return null;
+      }
+
+      const currentPullRequest = readWorktreePullRequest(
+        tentacleId,
+        context.terminal,
+        context.workspaceCwd,
+      );
+      if (currentPullRequest.status !== "open") {
+        throw new RuntimeInputError("No open pull request found for this branch.");
+      }
+      if (currentPullRequest.isDraft) {
+        throw new RuntimeInputError("Draft pull requests cannot be merged.");
+      }
+      if (currentPullRequest.mergeable === "CONFLICTING") {
+        throw new RuntimeInputError("Pull request has conflicts and cannot be merged.");
+      }
+
+      try {
+        gitClient.mergeCurrentBranchPullRequest({
+          cwd: context.workspaceCwd,
+          strategy: "squash",
+        });
+      } catch (error) {
+        throw new RuntimeInputError(
+          `Unable to merge pull request for ${tentacleId}: ${
+            error instanceof Error ? error.message : String(error)
+          }`,
+        );
+      }
+
+      return readWorktreePullRequest(tentacleId, context.terminal, context.workspaceCwd);
+    },
+  };
+};