@vicoa/cli 1.3.10 → 1.3.11-linux-x64

package/bin/_internal/integrations/github/claude-code-action/src/github/operations/branch-cleanup.ts

@@ -0,0 +1,132 @@
+import type { Octokits } from "../api/client";
+import { GITHUB_SERVER_URL } from "../api/config";
+import { $ } from "bun";
+
+export async function checkAndCommitOrDeleteBranch(
+  octokit: Octokits,
+  owner: string,
+  repo: string,
+  claudeBranch: string | undefined,
+  baseBranch: string,
+  useCommitSigning: boolean,
+): Promise<{ shouldDeleteBranch: boolean; branchLink: string }> {
+  let branchLink = "";
+  let shouldDeleteBranch = false;
+
+  if (claudeBranch) {
+    // First check if the branch exists remotely
+    let branchExistsRemotely = false;
+    try {
+      await octokit.rest.repos.getBranch({
+        owner,
+        repo,
+        branch: claudeBranch,
+      });
+      branchExistsRemotely = true;
+    } catch (error: any) {
+      if (error.status === 404) {
+        console.log(`Branch ${claudeBranch} does not exist remotely`);
+      } else {
+        console.error("Error checking if branch exists:", error);
+      }
+    }
+
+    // Only proceed if branch exists remotely
+    if (!branchExistsRemotely) {
+      console.log(
+        `Branch ${claudeBranch} does not exist remotely, no branch link will be added`,
+      );
+      return { shouldDeleteBranch: false, branchLink: "" };
+    }
+
+    // Check if Claude made any commits to the branch
+    try {
+      const { data: comparison } =
+        await octokit.rest.repos.compareCommitsWithBasehead({
+          owner,
+          repo,
+          basehead: `${baseBranch}...${claudeBranch}`,
+        });
+
+      // If there are no commits, check for uncommitted changes if not using commit signing
+      if (comparison.total_commits === 0) {
+        if (!useCommitSigning) {
+          console.log(
+            `Branch ${claudeBranch} has no commits from Claude, checking for uncommitted changes...`,
+          );
+
+          // Check for uncommitted changes using git status
+          try {
+            const gitStatus = await $`git status --porcelain`.quiet();
+            const hasUncommittedChanges =
+              gitStatus.stdout.toString().trim().length > 0;
+
+            if (hasUncommittedChanges) {
+              console.log("Found uncommitted changes, committing them...");
+
+              // Add all changes
+              await $`git add -A`;
+
+              // Commit with a descriptive message
+              const runId = process.env.GITHUB_RUN_ID || "unknown";
+              const commitMessage = `Auto-commit: Save uncommitted changes from Claude\n\nRun ID: ${runId}`;
+              await $`git commit -m ${commitMessage}`;
+
+              // Push the changes
+              await $`git push origin ${claudeBranch}`;
+
+              console.log(
+                "✅ Successfully committed and pushed uncommitted changes",
+              );
+
+              // Set branch link since we now have commits
+              const branchUrl = `${GITHUB_SERVER_URL}/${owner}/${repo}/tree/${claudeBranch}`;
+              branchLink = `\n[View branch](${branchUrl})`;
+            } else {
+              console.log(
+                "No uncommitted changes found, marking branch for deletion",
+              );
+              shouldDeleteBranch = true;
+            }
+          } catch (gitError) {
+            console.error("Error checking/committing changes:", gitError);
+            // If we can't check git status, assume the branch might have changes
+            const branchUrl = `${GITHUB_SERVER_URL}/${owner}/${repo}/tree/${claudeBranch}`;
+            branchLink = `\n[View branch](${branchUrl})`;
+          }
+        } else {
+          console.log(
+            `Branch ${claudeBranch} has no commits from Claude, will delete it`,
+          );
+          shouldDeleteBranch = true;
+        }
+      } else {
+        // Only add branch link if there are commits
+        const branchUrl = `${GITHUB_SERVER_URL}/${owner}/${repo}/tree/${claudeBranch}`;
+        branchLink = `\n[View branch](${branchUrl})`;
+      }
+    } catch (error) {
+      console.error("Error comparing commits on Claude branch:", error);
+      // If we can't compare but the branch exists remotely, include the branch link
+      const branchUrl = `${GITHUB_SERVER_URL}/${owner}/${repo}/tree/${claudeBranch}`;
+      branchLink = `\n[View branch](${branchUrl})`;
+    }
+  }
+
+  // Delete the branch if it has no commits
+  if (shouldDeleteBranch && claudeBranch) {
+    try {
+      await octokit.rest.git.deleteRef({
+        owner,
+        repo,
+        ref: `heads/${claudeBranch}`,
+      });
+      console.log(`✅ Deleted empty branch: ${claudeBranch}`);
+    } catch (deleteError) {
+      console.error(`Failed to delete branch ${claudeBranch}:`, deleteError);
+      // Continue even if deletion fails
+    }
+  }
+
+  return { shouldDeleteBranch, branchLink };
+}

package/bin/_internal/integrations/github/claude-code-action/src/github/operations/branch.ts

@@ -0,0 +1,163 @@
+#!/usr/bin/env bun
+
+/**
+ * Setup the appropriate branch based on the event type:
+ * - For PRs: Checkout the PR branch
+ * - For Issues: Create a new branch
+ */
+
+import { $ } from "bun";
+import * as core from "@actions/core";
+import type { ParsedGitHubContext } from "../context";
+import type { GitHubPullRequest } from "../types";
+import type { Octokits } from "../api/client";
+import type { FetchDataResult } from "../data/fetcher";
+
+export type BranchInfo = {
+  baseBranch: string;
+  claudeBranch?: string;
+  currentBranch: string;
+};
+
+export async function setupBranch(
+  octokits: Octokits,
+  githubData: FetchDataResult,
+  context: ParsedGitHubContext,
+): Promise<BranchInfo> {
+  const { owner, repo } = context.repository;
+  const entityNumber = context.entityNumber;
+  const { baseBranch, branchPrefix } = context.inputs;
+  const isPR = context.isPR;
+
+  if (isPR) {
+    const prData = githubData.contextData as GitHubPullRequest;
+    const prState = prData.state;
+
+    // Check if PR is closed or merged
+    if (prState === "CLOSED" || prState === "MERGED") {
+      console.log(
+        `PR #${entityNumber} is ${prState}, creating new branch from source...`,
+      );
+      // Fall through to create a new branch like we do for issues
+    } else {
+      // Handle open PR: Checkout the PR branch
+      console.log("This is an open PR, checking out PR branch...");
+
+      const branchName = prData.headRefName;
+
+      // Determine optimal fetch depth based on PR commit count, with a minimum of 20
+      const commitCount = prData.commits.totalCount;
+      const fetchDepth = Math.max(commitCount, 20);
+
+      console.log(
+        `PR #${entityNumber}: ${commitCount} commits, using fetch depth ${fetchDepth}`,
+      );
+
+      // Execute git commands to checkout PR branch (dynamic depth based on PR size)
+      await $`git fetch origin --depth=${fetchDepth} ${branchName}`;
+      await $`git checkout ${branchName} --`;
+
+      console.log(`Successfully checked out PR branch for PR #${entityNumber}`);
+
+      // For open PRs, we need to get the base branch of the PR
+      const baseBranch = prData.baseRefName;
+
+      return {
+        baseBranch,
+        currentBranch: branchName,
+      };
+    }
+  }
+
+  // Determine source branch - use baseBranch if provided, otherwise fetch default
+  let sourceBranch: string;
+
+  if (baseBranch) {
+    // Use provided base branch for source
+    sourceBranch = baseBranch;
+  } else {
+    // No base branch provided, fetch the default branch to use as source
+    const repoResponse = await octokits.rest.repos.get({
+      owner,
+      repo,
+    });
+    sourceBranch = repoResponse.data.default_branch;
+  }
+
+  // Generate branch name for either an issue or closed/merged PR
+  const entityType = isPR ? "pr" : "issue";
+
+  // Create Kubernetes-compatible timestamp: lowercase, hyphens only, shorter format
+  const now = new Date();
+  const timestamp = `${now.getFullYear()}${String(now.getMonth() + 1).padStart(2, "0")}${String(now.getDate()).padStart(2, "0")}-${String(now.getHours()).padStart(2, "0")}${String(now.getMinutes()).padStart(2, "0")}`;
+
+  // Ensure branch name is Kubernetes-compatible:
+  // - Lowercase only
+  // - Alphanumeric with hyphens
+  // - No underscores
+  // - Max 50 chars (to allow for prefixes)
+  const branchName = `${branchPrefix}${entityType}-${entityNumber}-${timestamp}`;
+  const newBranch = branchName.toLowerCase().substring(0, 50);
+
+  try {
+    // Get the SHA of the source branch to verify it exists
+    const sourceBranchRef = await octokits.rest.git.getRef({
+      owner,
+      repo,
+      ref: `heads/${sourceBranch}`,
+    });
+
+    const currentSHA = sourceBranchRef.data.object.sha;
+    console.log(`Source branch SHA: ${currentSHA}`);
+
+    // For commit signing, defer branch creation to the file ops server
+    if (context.inputs.useCommitSigning) {
+      console.log(
+        `Branch name generated: ${newBranch} (will be created by file ops server on first commit)`,
+      );
+
+      // Ensure we're on the source branch
+      console.log(`Fetching and checking out source branch: ${sourceBranch}`);
+      await $`git fetch origin ${sourceBranch} --depth=1`;
+      await $`git checkout ${sourceBranch}`;
+
+      // Set outputs for GitHub Actions
+      core.setOutput("CLAUDE_BRANCH", newBranch);
+      core.setOutput("BASE_BRANCH", sourceBranch);
+      return {
+        baseBranch: sourceBranch,
+        claudeBranch: newBranch,
+        currentBranch: sourceBranch, // Stay on source branch for now
+      };
+    }
+
+    // For non-signing case, create and checkout the branch locally only
+    console.log(
+      `Creating local branch ${newBranch} for ${entityType} #${entityNumber} from source branch: ${sourceBranch}...`,
+    );
+
+    // Fetch and checkout the source branch first to ensure we branch from the correct base
+    console.log(`Fetching and checking out source branch: ${sourceBranch}`);
+    await $`git fetch origin ${sourceBranch} --depth=1`;
+    await $`git checkout ${sourceBranch}`;
+
+    // Create and checkout the new branch from the source branch
+    await $`git checkout -b ${newBranch}`;
+
+    console.log(
+      `Successfully created and checked out local branch: ${newBranch}`,
+    );
+
+    // Set outputs for GitHub Actions
+    core.setOutput("CLAUDE_BRANCH", newBranch);
+    core.setOutput("BASE_BRANCH", sourceBranch);
+    return {
+      baseBranch: sourceBranch,
+      claudeBranch: newBranch,
+      currentBranch: newBranch,
+    };
+  } catch (error) {
+    console.error("Error in branch setup:", error);
+    process.exit(1);
+  }
+}

package/bin/_internal/integrations/github/claude-code-action/src/github/operations/comment-logic.ts

@@ -0,0 +1,203 @@
+import { GITHUB_SERVER_URL } from "../api/config";
+
+export type ExecutionDetails = {
+  cost_usd?: number;
+  duration_ms?: number;
+  duration_api_ms?: number;
+};
+
+export type CommentUpdateInput = {
+  currentBody: string;
+  actionFailed: boolean;
+  executionDetails: ExecutionDetails | null;
+  jobUrl: string;
+  branchLink?: string;
+  prLink?: string;
+  branchName?: string;
+  triggerUsername?: string;
+  errorDetails?: string;
+};
+
+export function ensureProperlyEncodedUrl(url: string): string | null {
+  try {
+    // First, try to parse the URL to see if it's already properly encoded
+    new URL(url);
+    if (url.includes(" ")) {
+      const [baseUrl, queryString] = url.split("?");
+      if (queryString) {
+        // Parse query parameters and re-encode them properly
+        const params = new URLSearchParams();
+        const pairs = queryString.split("&");
+        for (const pair of pairs) {
+          const [key, value = ""] = pair.split("=");
+          if (key) {
+            // Decode first in case it's partially encoded, then encode properly
+            params.set(key, decodeURIComponent(value));
+          }
+        }
+        return `${baseUrl}?${params.toString()}`;
+      }
+      // If no query string, just encode spaces
+      return url.replace(/ /g, "%20");
+    }
+    return url;
+  } catch (e) {
+    // If URL parsing fails, try basic fixes
+    try {
+      // Replace spaces with %20
+      let fixedUrl = url.replace(/ /g, "%20");
+
+      // Ensure colons in parameter values are encoded (but not in http:// or after domain)
+      const urlParts = fixedUrl.split("?");
+      if (urlParts.length > 1 && urlParts[1]) {
+        const [baseUrl, queryString] = urlParts;
+        // Encode colons in the query string that aren't already encoded
+        const fixedQuery = queryString.replace(/([^%]|^):(?!%2F%2F)/g, "$1%3A");
+        fixedUrl = `${baseUrl}?${fixedQuery}`;
+      }
+
+      // Try to validate the fixed URL
+      new URL(fixedUrl);
+      return fixedUrl;
+    } catch {
+      // If we still can't create a valid URL, return null
+      return null;
+    }
+  }
+}
+
+export function updateCommentBody(input: CommentUpdateInput): string {
+  const originalBody = input.currentBody;
+  const {
+    executionDetails,
+    jobUrl,
+    branchLink,
+    prLink,
+    actionFailed,
+    branchName,
+    triggerUsername,
+    errorDetails,
+  } = input;
+
+  // Extract content from the original comment body
+  // First, remove the "Claude Code is working…" or "Claude Code is working..." message
+  const workingPattern = /Claude Code is working[…\.]{1,3}(?:\s*<img[^>]*>)?/i;
+  let bodyContent = originalBody.replace(workingPattern, "").trim();
+
+  // Check if there's a PR link in the content
+  let prLinkFromContent = "";
+
+  // Match the entire markdown link structure
+  const prLinkPattern = /\[Create .* PR\]\((.*)\)$/m;
+  const prLinkMatch = bodyContent.match(prLinkPattern);
+
+  if (prLinkMatch && prLinkMatch[1]) {
+    const encodedUrl = ensureProperlyEncodedUrl(prLinkMatch[1]);
+    if (encodedUrl) {
+      prLinkFromContent = encodedUrl;
+      // Remove the PR link from the content
+      bodyContent = bodyContent.replace(prLinkMatch[0], "").trim();
+    }
+  }
+
+  // Calculate duration string if available
+  let durationStr = "";
+  if (executionDetails?.duration_ms !== undefined) {
+    const totalSeconds = Math.round(executionDetails.duration_ms / 1000);
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    durationStr = minutes > 0 ? `${minutes}m ${seconds}s` : `${seconds}s`;
+  }
+
+  // Build the header
+  let header = "";
+
+  if (actionFailed) {
+    header = "**Claude encountered an error";
+    if (durationStr) {
+      header += ` after ${durationStr}`;
+    }
+    header += "**";
+  } else {
+    // Get the username from triggerUsername or extract from content
+    const usernameMatch = bodyContent.match(/@([a-zA-Z0-9-]+)/);
+    const username =
+      triggerUsername || (usernameMatch ? usernameMatch[1] : "user");
+
+    header = `**Claude finished @${username}'s task`;
+    if (durationStr) {
+      header += ` in ${durationStr}`;
+    }
+    header += "**";
+  }
+
+  // Add links section
+  let links = ` —— [View job](${jobUrl})`;
+
+  // Add branch name with link
+  if (branchName || branchLink) {
+    let finalBranchName = branchName;
+    let branchUrl = "";
+
+    if (branchLink) {
+      // Extract the branch URL from the link
+      const urlMatch = branchLink.match(/\((https:\/\/.*)\)/);
+      if (urlMatch && urlMatch[1]) {
+        branchUrl = urlMatch[1];
+      }
+
+      // Extract branch name from link if not provided
+      if (!finalBranchName) {
+        const branchNameMatch = branchLink.match(/tree\/([^"'\)]+)/);
+        if (branchNameMatch) {
+          finalBranchName = branchNameMatch[1];
+        }
+      }
+    }
+
+    // If we don't have a URL yet but have a branch name, construct it
+    if (!branchUrl && finalBranchName) {
+      // Extract owner/repo from jobUrl
+      const repoMatch = jobUrl.match(/github\.com\/([^\/]+)\/([^\/]+)\//);
+      if (repoMatch) {
+        branchUrl = `${GITHUB_SERVER_URL}/${repoMatch[1]}/${repoMatch[2]}/tree/${finalBranchName}`;
+      }
+    }
+
+    if (finalBranchName && branchUrl) {
+      links += ` • [\`${finalBranchName}\`](${branchUrl})`;
+    } else if (finalBranchName) {
+      links += ` • \`${finalBranchName}\``;
+    }
+  }
+
+  // Add PR link (either from content or provided)
+  const prUrl =
+    prLinkFromContent || (prLink ? prLink.match(/\(([^)]+)\)/)?.[1] : "");
+  if (prUrl) {
+    links += ` • [Create PR ➔](${prUrl})`;
+  }
+
+  // Build the new body with blank line between header and separator
+  let newBody = `${header}${links}`;
+
+  // Add error details if available
+  if (actionFailed && errorDetails) {
+    newBody += `\n\n\`\`\`\n${errorDetails}\n\`\`\``;
+  }
+
+  newBody += `\n\n---\n`;
+
+  // Clean up the body content
+  // Remove any existing View job run, branch links from the bottom
+  bodyContent = bodyContent.replace(/\n?\[View job run\]\([^\)]+\)/g, "");
+  bodyContent = bodyContent.replace(/\n?\[View branch\]\([^\)]+\)/g, "");
+
+  // Remove any existing duration info at the bottom
+  bodyContent = bodyContent.replace(/\n*---\n*Duration: [0-9]+m? [0-9]+s/g, "");
+
+  // Add the cleaned body content
+  newBody += bodyContent;
+
+  return newBody.trim();
+}

package/bin/_internal/integrations/github/claude-code-action/src/github/operations/comments/common.ts

@@ -0,0 +1,33 @@
+import { GITHUB_SERVER_URL } from "../../api/config";
+
+export const SPINNER_HTML =
+  '<img src="https://github.com/user-attachments/assets/5ac382c7-e004-429b-8e35-7feb3e8f9c6f" width="14px" height="14px" style="vertical-align: middle; margin-left: 4px;" />';
+
+export function createJobRunLink(
+  owner: string,
+  repo: string,
+  runId: string,
+): string {
+  const jobRunUrl = `${GITHUB_SERVER_URL}/${owner}/${repo}/actions/runs/${runId}`;
+  return `[View job run](${jobRunUrl})`;
+}
+
+export function createBranchLink(
+  owner: string,
+  repo: string,
+  branchName: string,
+): string {
+  const branchUrl = `${GITHUB_SERVER_URL}/${owner}/${repo}/tree/${branchName}`;
+  return `\n[View branch](${branchUrl})`;
+}
+
+export function createCommentBody(
+  jobRunLink: string,
+  branchLink: string = "",
+): string {
+  return `Claude Code is working… ${SPINNER_HTML}
+
+I'll analyze this and get back to you.
+
+${jobRunLink}${branchLink}`;
+}

package/bin/_internal/integrations/github/claude-code-action/src/github/operations/comments/create-initial.ts

@@ -0,0 +1,111 @@
+#!/usr/bin/env bun
+
+/**
+ * Create the initial tracking comment when Claude Code starts working
+ * This comment shows the working status and includes a link to the job run
+ */
+
+import { appendFileSync } from "fs";
+import { createJobRunLink, createCommentBody } from "./common";
+import {
+  isPullRequestReviewCommentEvent,
+  isPullRequestEvent,
+  type ParsedGitHubContext,
+} from "../../context";
+import type { Octokit } from "@octokit/rest";
+
+const CLAUDE_APP_BOT_ID = 209825114;
+
+export async function createInitialComment(
+  octokit: Octokit,
+  context: ParsedGitHubContext,
+) {
+  const { owner, repo } = context.repository;
+
+  const jobRunLink = createJobRunLink(owner, repo, context.runId);
+  const initialBody = createCommentBody(jobRunLink);
+
+  try {
+    let response;
+
+    if (
+      context.inputs.useStickyComment &&
+      context.isPR &&
+      isPullRequestEvent(context)
+    ) {
+      const comments = await octokit.rest.issues.listComments({
+        owner,
+        repo,
+        issue_number: context.entityNumber,
+      });
+      const existingComment = comments.data.find((comment) => {
+        const idMatch = comment.user?.id === CLAUDE_APP_BOT_ID;
+        const botNameMatch =
+          comment.user?.type === "Bot" &&
+          comment.user?.login.toLowerCase().includes("claude");
+        const bodyMatch = comment.body === initialBody;
+
+        return idMatch || botNameMatch || bodyMatch;
+      });
+      if (existingComment) {
+        response = await octokit.rest.issues.updateComment({
+          owner,
+          repo,
+          comment_id: existingComment.id,
+          body: initialBody,
+        });
+      } else {
+        // Create new comment if no existing one found
+        response = await octokit.rest.issues.createComment({
+          owner,
+          repo,
+          issue_number: context.entityNumber,
+          body: initialBody,
+        });
+      }
+    } else if (isPullRequestReviewCommentEvent(context)) {
+      // Only use createReplyForReviewComment if it's a PR review comment AND we have a comment_id
+      response = await octokit.rest.pulls.createReplyForReviewComment({
+        owner,
+        repo,
+        pull_number: context.entityNumber,
+        comment_id: context.payload.comment.id,
+        body: initialBody,
+      });
+    } else {
+      // For all other cases (issues, issue comments, or missing comment_id)
+      response = await octokit.rest.issues.createComment({
+        owner,
+        repo,
+        issue_number: context.entityNumber,
+        body: initialBody,
+      });
+    }
+
+    // Output the comment ID for downstream steps using GITHUB_OUTPUT
+    const githubOutput = process.env.GITHUB_OUTPUT!;
+    appendFileSync(githubOutput, `claude_comment_id=${response.data.id}\n`);
+    console.log(`✅ Created initial comment with ID: ${response.data.id}`);
+    return response.data;
+  } catch (error) {
+    console.error("Error in initial comment:", error);
+
+    // Always fall back to regular issue comment if anything fails
+    try {
+      const response = await octokit.rest.issues.createComment({
+        owner,
+        repo,
+        issue_number: context.entityNumber,
+        body: initialBody,
+      });
+
+      const githubOutput = process.env.GITHUB_OUTPUT!;
+      appendFileSync(githubOutput, `claude_comment_id=${response.data.id}\n`);
+      console.log(`✅ Created fallback comment with ID: ${response.data.id}`);
+      return response.data;
+    } catch (fallbackError) {
+      console.error("Error creating fallback comment:", fallbackError);
+      throw fallbackError;
+    }
+  }
+}