@gokulvenkatareddy/cortex 0.1.7

package/apps/octogent/apps/web/src/app/hooks/usePromptLibrary.ts

@@ -0,0 +1,185 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+
+import { buildPromptItemUrl, buildPromptsUrl } from "../../runtime/runtimeEndpoints";
+import type { PromptDetail, PromptLibraryEntry } from "../types";
+
+type UsePromptLibraryOptions = {
+  enabled?: boolean;
+};
+
+type UsePromptLibraryResult = {
+  prompts: PromptLibraryEntry[];
+  selectedPromptName: string | null;
+  selectedPromptDetail: PromptDetail | null;
+  isLoadingPrompts: boolean;
+  isLoadingDetail: boolean;
+  isEditing: boolean;
+  editDraft: string;
+  errorMessage: string | null;
+  refreshPrompts: () => Promise<void>;
+  selectPrompt: (name: string) => void;
+  savePrompt: (name: string, content: string) => Promise<boolean>;
+  deletePrompt: (name: string) => Promise<boolean>;
+  startEditing: () => void;
+  cancelEditing: () => void;
+  setEditDraft: (draft: string) => void;
+  submitEdit: () => Promise<boolean>;
+};
+
+export const usePromptLibrary = ({
+  enabled = true,
+}: UsePromptLibraryOptions = {}): UsePromptLibraryResult => {
+  const [prompts, setPrompts] = useState<PromptLibraryEntry[]>([]);
+  const [selectedPromptName, setSelectedPromptName] = useState<string | null>(null);
+  const [selectedPromptDetail, setSelectedPromptDetail] = useState<PromptDetail | null>(null);
+  const [isLoadingPrompts, setIsLoadingPrompts] = useState(false);
+  const [isLoadingDetail, setIsLoadingDetail] = useState(false);
+  const [isEditing, setIsEditing] = useState(false);
+  const [editDraft, setEditDraft] = useState("");
+  const [errorMessage, setErrorMessage] = useState<string | null>(null);
+  const detailRequestRef = useRef(0);
+
+  const refreshPrompts = useCallback(async () => {
+    setIsLoadingPrompts(true);
+    setErrorMessage(null);
+    try {
+      const res = await fetch(buildPromptsUrl());
+      if (!res.ok) throw new Error("Failed to load prompts");
+      const data = (await res.json()) as { prompts: PromptLibraryEntry[] };
+      setPrompts(data.prompts);
+    } catch (err) {
+      setErrorMessage(err instanceof Error ? err.message : "Failed to load prompts");
+    } finally {
+      setIsLoadingPrompts(false);
+    }
+  }, []);
+
+  const selectPrompt = useCallback((name: string) => {
+    setSelectedPromptName(name);
+    setIsEditing(false);
+    setIsLoadingDetail(true);
+    setErrorMessage(null);
+
+    const requestId = ++detailRequestRef.current;
+
+    fetch(buildPromptItemUrl(name))
+      .then(async (res) => {
+        if (requestId !== detailRequestRef.current) return;
+        if (!res.ok) throw new Error("Prompt not found");
+        const data = (await res.json()) as PromptDetail;
+        setSelectedPromptDetail(data);
+      })
+      .catch((err) => {
+        if (requestId !== detailRequestRef.current) return;
+        setSelectedPromptDetail(null);
+        setErrorMessage(err instanceof Error ? err.message : "Failed to load prompt");
+      })
+      .finally(() => {
+        if (requestId === detailRequestRef.current) {
+          setIsLoadingDetail(false);
+        }
+      });
+  }, []);
+
+  const savePrompt = useCallback(
+    async (name: string, content: string): Promise<boolean> => {
+      setErrorMessage(null);
+      try {
+        const res = await fetch(buildPromptsUrl(), {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ name, content }),
+        });
+        if (!res.ok) {
+          const data = (await res.json()) as { error?: string };
+          throw new Error(data.error ?? "Failed to save prompt");
+        }
+        await refreshPrompts();
+        return true;
+      } catch (err) {
+        setErrorMessage(err instanceof Error ? err.message : "Failed to save prompt");
+        return false;
+      }
+    },
+    [refreshPrompts],
+  );
+
+  const deletePrompt = useCallback(
+    async (name: string): Promise<boolean> => {
+      setErrorMessage(null);
+      try {
+        const res = await fetch(buildPromptItemUrl(name), { method: "DELETE" });
+        if (!res.ok) throw new Error("Failed to delete prompt");
+        if (selectedPromptName === name) {
+          setSelectedPromptName(null);
+          setSelectedPromptDetail(null);
+        }
+        await refreshPrompts();
+        return true;
+      } catch (err) {
+        setErrorMessage(err instanceof Error ? err.message : "Failed to delete prompt");
+        return false;
+      }
+    },
+    [refreshPrompts, selectedPromptName],
+  );
+
+  const startEditing = useCallback(() => {
+    if (selectedPromptDetail) {
+      setEditDraft(selectedPromptDetail.content);
+      setIsEditing(true);
+    }
+  }, [selectedPromptDetail]);
+
+  const cancelEditing = useCallback(() => {
+    setIsEditing(false);
+    setEditDraft("");
+  }, []);
+
+  const submitEdit = useCallback(async (): Promise<boolean> => {
+    if (!selectedPromptName) return false;
+    setErrorMessage(null);
+    try {
+      const res = await fetch(buildPromptItemUrl(selectedPromptName), {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ content: editDraft }),
+      });
+      if (!res.ok) throw new Error("Failed to update prompt");
+      const data = (await res.json()) as PromptDetail;
+      setSelectedPromptDetail(data);
+      setIsEditing(false);
+      setEditDraft("");
+      await refreshPrompts();
+      return true;
+    } catch (err) {
+      setErrorMessage(err instanceof Error ? err.message : "Failed to update prompt");
+      return false;
+    }
+  }, [selectedPromptName, editDraft, refreshPrompts]);
+
+  useEffect(() => {
+    if (enabled) {
+      void refreshPrompts();
+    }
+  }, [enabled, refreshPrompts]);
+
+  return {
+    prompts,
+    selectedPromptName,
+    selectedPromptDetail,
+    isLoadingPrompts,
+    isLoadingDetail,
+    isEditing,
+    editDraft,
+    errorMessage,
+    refreshPrompts,
+    selectPrompt,
+    savePrompt,
+    deletePrompt,
+    startEditing,
+    cancelEditing,
+    setEditDraft,
+    submitEdit,
+  };
+};

package/apps/octogent/apps/web/src/app/hooks/useTentacleGitLifecycle.ts

@@ -0,0 +1,530 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import type { Dispatch, SetStateAction } from "react";
+
+import {
+  buildTentacleGitCommitUrl,
+  buildTentacleGitPullRequestMergeUrl,
+  buildTentacleGitPullRequestUrl,
+  buildTentacleGitPushUrl,
+  buildTentacleGitStatusUrl,
+  buildTentacleGitSyncUrl,
+} from "../../runtime/runtimeEndpoints";
+import type {
+  TentacleGitStatusSnapshot,
+  TentaclePullRequestSnapshot,
+  TerminalView,
+} from "../types";
+
+type UseTentacleGitLifecycleOptions = {
+  columns: TerminalView;
+};
+
+type UseTentacleGitLifecycleResult = {
+  gitStatusByTentacleId: Record<string, TentacleGitStatusSnapshot>;
+  gitStatusLoadingByTentacleId: Record<string, boolean>;
+  pullRequestByTentacleId: Record<string, TentaclePullRequestSnapshot>;
+  pullRequestLoadingByTentacleId: Record<string, boolean>;
+  openGitTentacleId: string | null;
+  openGitTentacleStatus: TentacleGitStatusSnapshot | null;
+  openGitTentaclePullRequest: TentaclePullRequestSnapshot | null;
+  gitCommitMessageDraft: string;
+  gitDialogError: string | null;
+  isGitDialogLoading: boolean;
+  isGitDialogMutating: boolean;
+  setGitCommitMessageDraft: Dispatch<SetStateAction<string>>;
+  openTentacleGitActions: (tentacleId: string) => void;
+  closeTentacleGitActions: () => void;
+  commitTentacleChanges: () => Promise<void>;
+  commitAndPushTentacleBranch: () => Promise<void>;
+  pushTentacleBranch: () => Promise<void>;
+  syncTentacleBranch: () => Promise<void>;
+  mergeTentaclePullRequest: () => Promise<void>;
+};
+
+const parseGitError = async (response: Response, fallback: string) => {
+  try {
+    const payload = (await response.json()) as { error?: unknown };
+    if (typeof payload.error === "string" && payload.error.trim().length > 0) {
+      return payload.error.trim();
+    }
+  } catch {
+    return fallback;
+  }
+
+  return fallback;
+};
+
+const parseTentacleGitStatus = (payload: unknown): TentacleGitStatusSnapshot | null => {
+  if (payload === null || payload === undefined || typeof payload !== "object") {
+    return null;
+  }
+
+  const record = payload as Record<string, unknown>;
+  if (
+    typeof record.tentacleId !== "string" ||
+    (record.workspaceMode !== "shared" && record.workspaceMode !== "worktree") ||
+    typeof record.branchName !== "string" ||
+    (record.upstreamBranchName !== null && typeof record.upstreamBranchName !== "string") ||
+    typeof record.isDirty !== "boolean" ||
+    typeof record.aheadCount !== "number" ||
+    typeof record.behindCount !== "number" ||
+    typeof record.hasConflicts !== "boolean" ||
+    !Array.isArray(record.changedFiles) ||
+    !record.changedFiles.every((file) => typeof file === "string") ||
+    (record.defaultBaseBranchName !== null && typeof record.defaultBaseBranchName !== "string")
+  ) {
+    return null;
+  }
+
+  return {
+    tentacleId: record.tentacleId,
+    workspaceMode: record.workspaceMode,
+    branchName: record.branchName,
+    upstreamBranchName: record.upstreamBranchName,
+    isDirty: record.isDirty,
+    aheadCount: record.aheadCount,
+    behindCount: record.behindCount,
+    insertedLineCount: typeof record.insertedLineCount === "number" ? record.insertedLineCount : 0,
+    deletedLineCount: typeof record.deletedLineCount === "number" ? record.deletedLineCount : 0,
+    hasConflicts: record.hasConflicts,
+    changedFiles: [...record.changedFiles],
+    defaultBaseBranchName: record.defaultBaseBranchName,
+  };
+};
+
+const parseTentaclePullRequest = (payload: unknown): TentaclePullRequestSnapshot | null => {
+  if (payload === null || payload === undefined || typeof payload !== "object") {
+    return null;
+  }
+
+  const record = payload as Record<string, unknown>;
+  if (
+    typeof record.tentacleId !== "string" ||
+    (record.workspaceMode !== "shared" && record.workspaceMode !== "worktree") ||
+    (record.status !== "none" &&
+      record.status !== "open" &&
+      record.status !== "merged" &&
+      record.status !== "closed") ||
+    (record.number !== null && typeof record.number !== "number") ||
+    (record.url !== null && typeof record.url !== "string") ||
+    (record.title !== null && typeof record.title !== "string") ||
+    (record.baseRef !== null && typeof record.baseRef !== "string") ||
+    (record.headRef !== null && typeof record.headRef !== "string") ||
+    (record.isDraft !== null && typeof record.isDraft !== "boolean") ||
+    (record.mergeable !== null &&
+      record.mergeable !== "MERGEABLE" &&
+      record.mergeable !== "CONFLICTING" &&
+      record.mergeable !== "UNKNOWN") ||
+    (record.mergeStateStatus !== null && typeof record.mergeStateStatus !== "string")
+  ) {
+    return null;
+  }
+
+  return {
+    tentacleId: record.tentacleId,
+    workspaceMode: record.workspaceMode,
+    status: record.status,
+    number: record.number,
+    url: record.url,
+    title: record.title,
+    baseRef: record.baseRef,
+    headRef: record.headRef,
+    isDraft: record.isDraft,
+    mergeable: record.mergeable,
+    mergeStateStatus: record.mergeStateStatus,
+  };
+};
+
+export const useTentacleGitLifecycle = ({
+  columns,
+}: UseTentacleGitLifecycleOptions): UseTentacleGitLifecycleResult => {
+  const [gitStatusByTentacleId, setGitStatusByTentacleId] = useState<
+    Record<string, TentacleGitStatusSnapshot>
+  >({});
+  const [gitStatusLoadingByTentacleId, setGitStatusLoadingByTentacleId] = useState<
+    Record<string, boolean>
+  >({});
+  const [gitStatusAttemptedTentacleIds, setGitStatusAttemptedTentacleIds] = useState<
+    Record<string, boolean>
+  >({});
+  const [pullRequestByTentacleId, setPullRequestByTentacleId] = useState<
+    Record<string, TentaclePullRequestSnapshot>
+  >({});
+  const [pullRequestLoadingByTentacleId, setPullRequestLoadingByTentacleId] = useState<
+    Record<string, boolean>
+  >({});
+  const [pullRequestAttemptedTentacleIds, setPullRequestAttemptedTentacleIds] = useState<
+    Record<string, boolean>
+  >({});
+  const [openGitTentacleId, setOpenGitTentacleId] = useState<string | null>(null);
+  const [gitCommitMessageDraft, setGitCommitMessageDraft] = useState("");
+  const [gitDialogError, setGitDialogError] = useState<string | null>(null);
+  const [isGitDialogMutating, setIsGitDialogMutating] = useState(false);
+
+  const fetchTentacleGitStatus = useCallback(async (tentacleId: string) => {
+    setGitStatusLoadingByTentacleId((current) => ({
+      ...current,
+      [tentacleId]: true,
+    }));
+
+    try {
+      const response = await fetch(buildTentacleGitStatusUrl(tentacleId), {
+        method: "GET",
+        headers: {
+          Accept: "application/json",
+        },
+      });
+      if (!response.ok) {
+        const errorMessage = await parseGitError(
+          response,
+          `Unable to fetch git status (${response.status}).`,
+        );
+        throw new Error(errorMessage);
+      }
+
+      const payload = parseTentacleGitStatus(await response.json());
+      if (!payload) {
+        throw new Error("Unable to parse git status response.");
+      }
+
+      setGitStatusByTentacleId((current) => ({
+        ...current,
+        [tentacleId]: payload,
+      }));
+      return payload;
+    } finally {
+      setGitStatusLoadingByTentacleId((current) => ({
+        ...current,
+        [tentacleId]: false,
+      }));
+    }
+  }, []);
+
+  const fetchTentaclePullRequest = useCallback(async (tentacleId: string) => {
+    setPullRequestLoadingByTentacleId((current) => ({
+      ...current,
+      [tentacleId]: true,
+    }));
+
+    try {
+      const response = await fetch(buildTentacleGitPullRequestUrl(tentacleId), {
+        method: "GET",
+        headers: {
+          Accept: "application/json",
+        },
+      });
+      if (!response.ok) {
+        const errorMessage = await parseGitError(
+          response,
+          `Unable to fetch pull request status (${response.status}).`,
+        );
+        throw new Error(errorMessage);
+      }
+
+      const payload = parseTentaclePullRequest(await response.json());
+      if (!payload) {
+        throw new Error("Unable to parse pull request response.");
+      }
+
+      setPullRequestByTentacleId((current) => ({
+        ...current,
+        [tentacleId]: payload,
+      }));
+      return payload;
+    } finally {
+      setPullRequestLoadingByTentacleId((current) => ({
+        ...current,
+        [tentacleId]: false,
+      }));
+    }
+  }, []);
+
+  const worktreeTentacleIds = useMemo(
+    () =>
+      columns
+        .filter((column) => column.workspaceMode === "worktree")
+        .map((column) => column.tentacleId),
+    [columns],
+  );
+
+  useEffect(() => {
+    const activeTentacleIds = new Set(columns.map((column) => column.tentacleId));
+    setGitStatusByTentacleId((current) =>
+      Object.fromEntries(
+        Object.entries(current).filter(([tentacleId]) => activeTentacleIds.has(tentacleId)),
+      ),
+    );
+    setGitStatusLoadingByTentacleId((current) =>
+      Object.fromEntries(
+        Object.entries(current).filter(([tentacleId]) => activeTentacleIds.has(tentacleId)),
+      ),
+    );
+    setGitStatusAttemptedTentacleIds((current) =>
+      Object.fromEntries(
+        Object.entries(current).filter(([tentacleId]) => activeTentacleIds.has(tentacleId)),
+      ),
+    );
+    setPullRequestByTentacleId((current) =>
+      Object.fromEntries(
+        Object.entries(current).filter(([tentacleId]) => activeTentacleIds.has(tentacleId)),
+      ),
+    );
+    setPullRequestLoadingByTentacleId((current) =>
+      Object.fromEntries(
+        Object.entries(current).filter(([tentacleId]) => activeTentacleIds.has(tentacleId)),
+      ),
+    );
+    setPullRequestAttemptedTentacleIds((current) =>
+      Object.fromEntries(
+        Object.entries(current).filter(([tentacleId]) => activeTentacleIds.has(tentacleId)),
+      ),
+    );
+    if (openGitTentacleId && !activeTentacleIds.has(openGitTentacleId)) {
+      setOpenGitTentacleId(null);
+      setGitDialogError(null);
+      setGitCommitMessageDraft("");
+    }
+  }, [columns, openGitTentacleId]);
+
+  useEffect(() => {
+    for (const tentacleId of worktreeTentacleIds) {
+      if (gitStatusAttemptedTentacleIds[tentacleId]) {
+        continue;
+      }
+
+      setGitStatusAttemptedTentacleIds((current) => ({
+        ...current,
+        [tentacleId]: true,
+      }));
+      void fetchTentacleGitStatus(tentacleId).catch((error: unknown) => {
+        console.warn(`[git] Failed to fetch status for tentacle ${tentacleId}:`, error);
+      });
+    }
+  }, [fetchTentacleGitStatus, gitStatusAttemptedTentacleIds, worktreeTentacleIds]);
+
+  useEffect(() => {
+    for (const tentacleId of worktreeTentacleIds) {
+      if (pullRequestAttemptedTentacleIds[tentacleId]) {
+        continue;
+      }
+
+      setPullRequestAttemptedTentacleIds((current) => ({
+        ...current,
+        [tentacleId]: true,
+      }));
+      void fetchTentaclePullRequest(tentacleId).catch((error: unknown) => {
+        console.warn(`[git] Failed to fetch pull request for tentacle ${tentacleId}:`, error);
+      });
+    }
+  }, [fetchTentaclePullRequest, pullRequestAttemptedTentacleIds, worktreeTentacleIds]);
+
+  const openTentacleGitActions = useCallback(
+    (tentacleId: string) => {
+      setOpenGitTentacleId(tentacleId);
+      setGitDialogError(null);
+      setGitCommitMessageDraft("");
+
+      void Promise.all([
+        fetchTentacleGitStatus(tentacleId),
+        fetchTentaclePullRequest(tentacleId),
+      ]).catch((error: unknown) => {
+        setGitDialogError(
+          error instanceof Error ? error.message : "Unable to fetch git lifecycle data.",
+        );
+      });
+    },
+    [fetchTentacleGitStatus, fetchTentaclePullRequest],
+  );
+
+  const closeTentacleGitActions = useCallback(() => {
+    setOpenGitTentacleId(null);
+    setGitDialogError(null);
+    setGitCommitMessageDraft("");
+  }, []);
+
+  const runGitMutation = useCallback(
+    async (
+      action: "commit" | "push" | "sync",
+      request: { body?: string; headers?: Record<string, string> } = {},
+    ): Promise<TentacleGitStatusSnapshot | null> => {
+      if (!openGitTentacleId) {
+        return null;
+      }
+
+      const endpoint =
+        action === "commit"
+          ? buildTentacleGitCommitUrl(openGitTentacleId)
+          : action === "push"
+            ? buildTentacleGitPushUrl(openGitTentacleId)
+            : buildTentacleGitSyncUrl(openGitTentacleId);
+
+      setIsGitDialogMutating(true);
+      setGitDialogError(null);
+      try {
+        const response = await fetch(endpoint, {
+          method: "POST",
+          headers: {
+            Accept: "application/json",
+            ...request.headers,
+          },
+          body: request.body ?? null,
+        });
+
+        if (!response.ok) {
+          const errorMessage = await parseGitError(
+            response,
+            `Unable to ${action} (${response.status}).`,
+          );
+          throw new Error(errorMessage);
+        }
+
+        const payload = parseTentacleGitStatus(await response.json());
+        if (!payload) {
+          throw new Error("Unable to parse git lifecycle response.");
+        }
+
+        setGitStatusByTentacleId((current) => ({
+          ...current,
+          [openGitTentacleId]: payload,
+        }));
+        return payload;
+      } catch (error) {
+        setGitDialogError(
+          error instanceof Error ? error.message : `Unable to ${action} tentacle worktree.`,
+        );
+        return null;
+      } finally {
+        setIsGitDialogMutating(false);
+      }
+    },
+    [openGitTentacleId],
+  );
+
+  const runPullRequestMutation = useCallback(
+    async (request: { body?: string; headers?: Record<string, string> } = {}) => {
+      if (!openGitTentacleId) {
+        return;
+      }
+
+      const endpoint = buildTentacleGitPullRequestMergeUrl(openGitTentacleId);
+
+      setIsGitDialogMutating(true);
+      setGitDialogError(null);
+      try {
+        const response = await fetch(endpoint, {
+          method: "POST",
+          headers: {
+            Accept: "application/json",
+            ...request.headers,
+          },
+          body: request.body ?? null,
+        });
+
+        if (!response.ok) {
+          const errorMessage = await parseGitError(
+            response,
+            `Unable to merge pull request (${response.status}).`,
+          );
+          throw new Error(errorMessage);
+        }
+
+        const payload = parseTentaclePullRequest(await response.json());
+        if (!payload) {
+          throw new Error("Unable to parse pull request response.");
+        }
+
+        setPullRequestByTentacleId((current) => ({
+          ...current,
+          [openGitTentacleId]: payload,
+        }));
+      } catch (error) {
+        setGitDialogError(error instanceof Error ? error.message : "Unable to merge pull request.");
+      } finally {
+        setIsGitDialogMutating(false);
+      }
+    },
+    [openGitTentacleId],
+  );
+
+  const commitTentacleChanges = useCallback(async () => {
+    const message = gitCommitMessageDraft.trim();
+    if (message.length === 0) {
+      setGitDialogError("Commit message cannot be empty.");
+      return;
+    }
+
+    const committed = await runGitMutation("commit", {
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ message }),
+    });
+    if (committed) {
+      setGitCommitMessageDraft("");
+    }
+  }, [gitCommitMessageDraft, runGitMutation]);
+
+  const commitAndPushTentacleBranch = useCallback(async () => {
+    const message = gitCommitMessageDraft.trim();
+    if (message.length === 0) {
+      setGitDialogError("Commit message cannot be empty.");
+      return;
+    }
+
+    const committed = await runGitMutation("commit", {
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ message }),
+    });
+    if (!committed) {
+      return;
+    }
+    setGitCommitMessageDraft("");
+    await runGitMutation("push");
+  }, [gitCommitMessageDraft, runGitMutation]);
+
+  const pushTentacleBranch = useCallback(async () => {
+    await runGitMutation("push");
+  }, [runGitMutation]);
+
+  const syncTentacleBranch = useCallback(async () => {
+    await runGitMutation("sync");
+  }, [runGitMutation]);
+
+  const mergeTentaclePullRequest = useCallback(async () => {
+    await runPullRequestMutation();
+  }, [runPullRequestMutation]);
+
+  const openGitTentacleStatus =
+    openGitTentacleId !== null ? (gitStatusByTentacleId[openGitTentacleId] ?? null) : null;
+  const openGitTentaclePullRequest =
+    openGitTentacleId !== null ? (pullRequestByTentacleId[openGitTentacleId] ?? null) : null;
+  const isGitDialogLoading =
+    openGitTentacleId !== null
+      ? (gitStatusLoadingByTentacleId[openGitTentacleId] ?? false) ||
+        (pullRequestLoadingByTentacleId[openGitTentacleId] ?? false)
+      : false;
+
+  return {
+    gitStatusByTentacleId,
+    gitStatusLoadingByTentacleId,
+    pullRequestByTentacleId,
+    pullRequestLoadingByTentacleId,
+    openGitTentacleId,
+    openGitTentacleStatus,
+    openGitTentaclePullRequest,
+    gitCommitMessageDraft,
+    gitDialogError,
+    isGitDialogLoading,
+    isGitDialogMutating,
+    setGitCommitMessageDraft,
+    openTentacleGitActions,
+    closeTentacleGitActions,
+    commitTentacleChanges,
+    commitAndPushTentacleBranch,
+    pushTentacleBranch,
+    syncTentacleBranch,
+    mergeTentaclePullRequest,
+  };
+};