GitActionsControl.logic.ts

import type {
  GitActionFailure,
  GitRunStackedActionResult,
  GitStackedAction,
  GitStatusResult,
} from "@okcode/contracts";

export type GitActionIconName = "commit" | "push" | "pr";

export type GitDialogAction = "commit" | "push" | "create_pr";

export interface GitActionMenuItem {
  id: "commit" | "push" | "pr";
  label: string;
  disabled: boolean;
  icon: GitActionIconName;
  kind: "open_dialog" | "open_pr";
  dialogAction?: GitDialogAction;
}

export type GitPullRequestMenuItemId = "open_in_browser" | "copy_pr_number" | "copy_pr_link";

export interface GitPullRequestMenuItem {
  id: GitPullRequestMenuItemId;
  label: string;
}

export interface GitQuickAction {
  label: string;
  disabled: boolean;
  kind: "run_action" | "run_pull" | "open_pr" | "show_hint" | "resolve_conflicts";
  action?: GitStackedAction;
  hint?: string;
}

export interface GitSyncAction {
  label: string;
  disabled: boolean;
  kind: "run_action" | "run_pull" | "show_hint";
  action?: "commit_push";
  hint?: string;
}

export interface DefaultBranchActionDialogCopy {
  title: string;
  description: string;
  continueLabel: string;
}

export type DefaultBranchConfirmableAction = "commit_push" | "commit_push_pr";

const SHORT_SHA_LENGTH = 7;
const TOAST_DESCRIPTION_MAX = 72;

function shortenSha(sha: string | undefined): string | null {
  if (!sha) return null;
  return sha.slice(0, SHORT_SHA_LENGTH);
}

function truncateText(
  value: string | undefined,
  maxLength = TOAST_DESCRIPTION_MAX,
): string | undefined {
  if (!value) return undefined;
  if (value.length <= maxLength) return value;
  if (maxLength <= 3) return "...".slice(0, maxLength);
  return `${value.slice(0, Math.max(0, maxLength - 3)).trimEnd()}...`;
}

export function formatOpenPullRequestLabel(prNumber: number | undefined): string {
  return prNumber ? `View PR #${prNumber}` : "View PR";
}

export function buildGitActionProgressStages(input: {
  action: GitStackedAction;
  hasCustomCommitMessage: boolean;
  hasWorkingTreeChanges: boolean;
  forcePushOnly?: boolean;
  pushTarget?: string;
  featureBranch?: boolean;
}): string[] {
  const branchStages = input.featureBranch ? ["Preparing feature branch..."] : [];
  const shouldIncludeCommitStages =
    !input.forcePushOnly && (input.action === "commit" || input.hasWorkingTreeChanges);
  const commitStages = !shouldIncludeCommitStages
    ? []
    : input.hasCustomCommitMessage
      ? ["Committing..."]
      : ["Generating commit message...", "Committing..."];
  const pushStage = input.pushTarget ? `Pushing to ${input.pushTarget}...` : "Pushing...";
  if (input.action === "commit") {
    return [...branchStages, ...commitStages];
  }
  if (input.action === "commit_push") {
    return [...branchStages, ...commitStages, pushStage];
  }
  return [...branchStages, ...commitStages, pushStage, "Creating PR..."];
}

const withDescription = (title: string, description: string | undefined) =>
  description ? { title, description } : { title };

export function buildPullRequestMenuItems(
  gitStatus: GitStatusResult | null,
): GitPullRequestMenuItem[] {
  if (gitStatus?.pr?.state !== "open") return [];

  return [
    { id: "open_in_browser", label: "Open in browser" },
    { id: "copy_pr_number", label: "Copy PR number" },
    { id: "copy_pr_link", label: "Copy PR link" },
  ];
}

export function summarizeGitResult(result: GitRunStackedActionResult): {
  title: string;
  description?: string;
} {
  if (result.pr.status === "created" || result.pr.status === "opened_existing") {
    const prNumber = result.pr.number ? ` #${result.pr.number}` : "";
    const title = `${result.pr.status === "created" ? "Created PR" : "Opened PR"}${prNumber}`;
    return withDescription(title, truncateText(result.pr.title));
  }

  if (result.push.status === "pushed") {
    const shortSha = shortenSha(result.commit.commitSha);
    const branch = result.push.upstreamBranch ?? result.push.branch;
    const pushedCommitPart = shortSha ? ` ${shortSha}` : "";
    const branchPart = branch ? ` to ${branch}` : "";
    return withDescription(
      `Pushed${pushedCommitPart}${branchPart}`,
      truncateText(result.commit.subject),
    );
  }

  if (result.commit.status === "created") {
    const shortSha = shortenSha(result.commit.commitSha);
    const title = shortSha ? `Committed ${shortSha}` : "Committed changes";
    return withDescription(title, truncateText(result.commit.subject));
  }

  return { title: "Done" };
}

export function summarizeGitFailure(failure: GitActionFailure): {
  title: string;
  description?: string;
} {
  return withDescription(failure.title, truncateText(failure.summary));
}

export function resolveGitFailureRetryLabel(failure: GitActionFailure): string {
  if (failure.phase === "pr") {
    return "Retry PR";
  }
  if (failure.phase === "push") {
    return "Retry push";
  }
  if (failure.phase === "commit") {
    return "Retry commit";
  }
  return "Retry";
}

export function buildMenuItems(
  gitStatus: GitStatusResult | null,
  isBusy: boolean,
  hasOriginRemote = true,
): GitActionMenuItem[] {
  if (!gitStatus) return [];

  const hasBranch = gitStatus.branch !== null;
  const hasChanges = gitStatus.hasWorkingTreeChanges;
  const hasConflicts = gitStatus.hasConflicts;
  const hasOpenPr = gitStatus.pr?.state === "open";
  const isBehind = gitStatus.behindCount > 0;
  const canPushWithoutUpstream = hasOriginRemote && !gitStatus.hasUpstream;
  const canCommit = !isBusy && hasChanges && !hasConflicts;
  const canPush =
    !isBusy &&
    hasBranch &&
    !hasChanges &&
    !hasConflicts &&
    !isBehind &&
    gitStatus.aheadCount > 0 &&
    (gitStatus.hasUpstream || canPushWithoutUpstream);
  const canCreatePr =
    !isBusy &&
    hasBranch &&
    !hasChanges &&
    !hasConflicts &&
    !hasOpenPr &&
    gitStatus.aheadCount > 0 &&
    !isBehind &&
    (gitStatus.hasUpstream || canPushWithoutUpstream);
  const canOpenPr = !isBusy && hasOpenPr;

  return [
    {
      id: "commit",
      label: "Commit",
      disabled: !canCommit,
      icon: "commit",
      kind: "open_dialog",
      dialogAction: "commit",
    },
    {
      id: "push",
      label: "Push",
      disabled: !canPush,
      icon: "push",
      kind: "open_dialog",
      dialogAction: "push",
    },
    hasOpenPr
      ? {
          id: "pr",
          label: formatOpenPullRequestLabel(gitStatus.pr?.number),
          disabled: !canOpenPr,
          icon: "pr",
          kind: "open_pr",
        }
      : {
          id: "pr",
          label: "Create PR",
          disabled: !canCreatePr,
          icon: "pr",
          kind: "open_dialog",
          dialogAction: "create_pr",
        },
  ];
}

export function resolveQuickAction(
  gitStatus: GitStatusResult | null,
  isBusy: boolean,
  isDefaultBranch = false,
  hasOriginRemote = true,
): GitQuickAction {
  if (isBusy) {
    return { label: "Commit", disabled: true, kind: "show_hint", hint: "Git action in progress." };
  }

  if (!gitStatus) {
    return {
      label: "Commit",
      disabled: true,
      kind: "show_hint",
      hint: "Git status is unavailable.",
    };
  }

  const hasBranch = gitStatus.branch !== null;
  const hasChanges = gitStatus.hasWorkingTreeChanges;
  const hasOpenPr = gitStatus.pr?.state === "open";
  const isAhead = gitStatus.aheadCount > 0;
  const isBehind = gitStatus.behindCount > 0;
  const isDiverged = isAhead && isBehind;
  const hasConflicts = gitStatus.hasConflicts;

  if (!hasBranch) {
    return {
      label: "Commit",
      disabled: true,
      kind: "show_hint",
      hint: "Create and checkout a branch before pushing or opening a PR.",
    };
  }

  if (hasConflicts) {
    return {
      label: "Resolve conflicts",
      disabled: false,
      kind: "resolve_conflicts",
      hint:
        gitStatus.conflictedFiles.length > 0
          ? `Open ${gitStatus.conflictedFiles.length === 1 ? "the conflicted file" : `${gitStatus.conflictedFiles.length} conflicted files`} in your editor.`
          : "Resolve merge conflicts before committing, pulling, or pushing.",
    };
  }

  if (hasChanges) {
    if (!gitStatus.hasUpstream && !hasOriginRemote) {
      return { label: "Commit", disabled: false, kind: "run_action", action: "commit" };
    }
    if (hasOpenPr || isDefaultBranch) {
      return { label: "Commit & push", disabled: false, kind: "run_action", action: "commit_push" };
    }
    return {
      label: "Commit, push & PR",
      disabled: false,
      kind: "run_action",
      action: "commit_push_pr",
    };
  }

  if (!gitStatus.hasUpstream) {
    if (!hasOriginRemote) {
      if (hasOpenPr && !isAhead) {
        return {
          label: formatOpenPullRequestLabel(gitStatus.pr?.number),
          disabled: false,
          kind: "open_pr",
        };
      }
      return {
        label: "Push",
        disabled: true,
        kind: "show_hint",
        hint: 'Add an "origin" remote before pushing or creating a PR.',
      };
    }
    if (!isAhead) {
      if (hasOpenPr) {
        return {
          label: formatOpenPullRequestLabel(gitStatus.pr?.number),
          disabled: false,
          kind: "open_pr",
        };
      }
      return {
        label: "Push",
        disabled: true,
        kind: "show_hint",
        hint: "No local commits to push.",
      };
    }
    if (hasOpenPr || isDefaultBranch) {
      return { label: "Push", disabled: false, kind: "run_action", action: "commit_push" };
    }
    return {
      label: "Push & create PR",
      disabled: false,
      kind: "run_action",
      action: "commit_push_pr",
    };
  }

  if (isDiverged) {
    return {
      label: "Sync branch",
      disabled: true,
      kind: "show_hint",
      hint: "Branch has diverged from upstream. Rebase/merge first.",
    };
  }

  if (isBehind) {
    return {
      label: "Pull",
      disabled: false,
      kind: "run_pull",
    };
  }

  if (isAhead) {
    if (hasOpenPr || isDefaultBranch) {
      return { label: "Push", disabled: false, kind: "run_action", action: "commit_push" };
    }
    return {
      label: "Push & create PR",
      disabled: false,
      kind: "run_action",
      action: "commit_push_pr",
    };
  }

  if (hasOpenPr && gitStatus.hasUpstream) {
    return {
      label: formatOpenPullRequestLabel(gitStatus.pr?.number),
      disabled: false,
      kind: "open_pr",
    };
  }

  return {
    label: "Commit",
    disabled: true,
    kind: "show_hint",
    hint: "Branch is up to date. No action needed.",
  };
}

export function resolveSyncAction(
  gitStatus: GitStatusResult | null,
  isBusy: boolean,
): GitSyncAction | null {
  if (!gitStatus) return null;
  if (
    gitStatus.branch === null ||
    gitStatus.hasWorkingTreeChanges ||
    gitStatus.hasConflicts ||
    !gitStatus.hasUpstream
  ) {
    return null;
  }

  const isAhead = gitStatus.aheadCount > 0;
  const isBehind = gitStatus.behindCount > 0;

  if (!isAhead && !isBehind) {
    return null;
  }

  if (isBusy) {
    return {
      label: "Sync branch",
      disabled: true,
      kind: "show_hint",
      hint: "Git action in progress.",
    };
  }

  if (isAhead && isBehind) {
    return {
      label: "Sync branch",
      disabled: true,
      kind: "show_hint",
      hint: "Branch has diverged from upstream. Rebase/merge first.",
    };
  }

  if (isBehind) {
    return {
      label: "Sync branch",
      disabled: false,
      kind: "run_pull",
    };
  }

  return {
    label: "Sync branch",
    disabled: false,
    kind: "run_action",
    action: "commit_push",
  };
}

export function requiresDefaultBranchConfirmation(
  action: GitStackedAction,
  isDefaultBranch: boolean,
): boolean {
  if (!isDefaultBranch) return false;
  return action === "commit_push" || action === "commit_push_pr";
}

export function resolveDefaultBranchActionDialogCopy(input: {
  action: DefaultBranchConfirmableAction;
  branchName: string;
  includesCommit: boolean;
}): DefaultBranchActionDialogCopy {
  const branchLabel = input.branchName;
  const suffix = ` on "${branchLabel}". You can continue on this branch or create a feature branch and run the same action there.`;

  if (input.action === "commit_push") {
    if (input.includesCommit) {
      return {
        title: "Commit & push to default branch?",
        description: `This action will commit and push changes${suffix}`,
        continueLabel: `Commit & push to ${branchLabel}`,
      };
    }
    return {
      title: "Push to default branch?",
      description: `This action will push local commits${suffix}`,
      continueLabel: `Push to ${branchLabel}`,
    };
  }

  if (input.includesCommit) {
    return {
      title: "Commit, push & create PR from default branch?",
      description: `This action will commit, push, and create a PR${suffix}`,
      continueLabel: `Commit, push & create PR`,
    };
  }
  return {
    title: "Push & create PR from default branch?",
    description: `This action will push local commits and create a PR${suffix}`,
    continueLabel: "Push & create PR",
  };
}

export function buildHookFailureAgentPrompt(failure: GitActionFailure): string {
  const sections: string[] = [
    "A git commit hook failed and blocked my commit. Please analyze the errors and fix them so I can retry.",
  ];
  if (failure.command) {
    sections.push(`**Command that failed:**\n\`\`\`\n${failure.command}\n\`\`\``);
  }
  if (failure.detail) {
    sections.push(`**Error summary:**\n${failure.detail}`);
  }
  if (failure.rawMessage) {
    sections.push(`**Full hook output:**\n\`\`\`\n${failure.rawMessage}\n\`\`\``);
  }
  sections.push(
    "Please:\n1. Analyze each error in the hook output\n2. Fix the affected files\n3. Let me know when the fixes are ready so I can retry the commit",
  );
  return sections.join("\n\n");
}

// Re-export from shared for backwards compatibility in this module's exports
export { resolveAutoFeatureBranchName } from "@okcode/shared/git";