@vicoa/cli 1.3.10 → 1.3.11-linux-x64

package/bin/_internal/integrations/github/claude-code-action/src/entrypoints/prepare.ts

@@ -0,0 +1,98 @@
+#!/usr/bin/env bun
+
+/**
+ * Prepare the Claude action by checking trigger conditions, verifying human actor,
+ * and creating the initial tracking comment
+ */
+
+import * as core from "@actions/core";
+import { setupGitHubToken } from "../github/token";
+import { checkWritePermissions } from "../github/validation/permissions";
+import { createOctokit } from "../github/api/client";
+import { parseGitHubContext, isEntityContext } from "../github/context";
+import { getMode } from "../modes/registry";
+import { prepare } from "../prepare";
+import { collectActionInputsPresence } from "./collect-inputs";
+
+async function run() {
+  try {
+    collectActionInputsPresence();
+
+    // Parse GitHub context first to enable mode detection
+    const context = parseGitHubContext();
+
+    // Auto-detect mode based on context
+    const mode = getMode(context);
+
+    // Setup GitHub token
+    const githubToken = await setupGitHubToken();
+    const octokit = createOctokit(githubToken);
+
+    // Step 3: Check write permissions (only for entity contexts)
+    if (isEntityContext(context)) {
+      const hasWritePermissions = await checkWritePermissions(
+        octokit.rest,
+        context,
+      );
+      if (!hasWritePermissions) {
+        throw new Error(
+          "Actor does not have write permissions to the repository",
+        );
+      }
+    }
+
+    // Check trigger conditions
+    const containsTrigger = mode.shouldTrigger(context);
+
+    // Debug logging
+    console.log(`Mode: ${mode.name}`);
+    console.log(`Context prompt: ${context.inputs?.prompt || "NO PROMPT"}`);
+    console.log(`Trigger result: ${containsTrigger}`);
+
+    // Set output for action.yml to check
+    core.setOutput("contains_trigger", containsTrigger.toString());
+
+    if (!containsTrigger) {
+      console.log("No trigger found, skipping remaining steps");
+      // Still set github_token output even when skipping
+      core.setOutput("github_token", githubToken);
+      return;
+    }
+
+    // Step 5: Use the new modular prepare function
+    const result = await prepare({
+      context,
+      octokit,
+      mode,
+      githubToken,
+    });
+
+    // MCP config is handled by individual modes (tag/agent) and included in their claude_args output
+
+    // Expose the GitHub token (Claude App token) as an output
+    core.setOutput("github_token", githubToken);
+
+    // Step 6: Get system prompt from mode if available
+    if (mode.getSystemPrompt) {
+      const modeContext = mode.prepareContext(context, {
+        commentId: result.commentId,
+        baseBranch: result.branchInfo.baseBranch,
+        claudeBranch: result.branchInfo.claudeBranch,
+      });
+      const systemPrompt = mode.getSystemPrompt(modeContext);
+      if (systemPrompt) {
+        core.exportVariable("APPEND_SYSTEM_PROMPT", systemPrompt);
+      }
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    core.setFailed(`Prepare step failed with error: ${errorMessage}`);
+    // Also output the clean error message for the action to capture
+    core.setOutput("prepare_error", errorMessage);
+    process.exit(1);
+  }
+}
+
+if (import.meta.main) {
+  run();
+}

package/bin/_internal/integrations/github/claude-code-action/src/entrypoints/update-comment-link.ts

@@ -0,0 +1,245 @@
+#!/usr/bin/env bun
+
+import { createOctokit } from "../github/api/client";
+import * as fs from "fs/promises";
+import {
+  updateCommentBody,
+  type CommentUpdateInput,
+} from "../github/operations/comment-logic";
+import {
+  parseGitHubContext,
+  isPullRequestReviewCommentEvent,
+  isEntityContext,
+} from "../github/context";
+import { GITHUB_SERVER_URL } from "../github/api/config";
+import { checkAndCommitOrDeleteBranch } from "../github/operations/branch-cleanup";
+import { updateClaudeComment } from "../github/operations/comments/update-claude-comment";
+
+async function run() {
+  try {
+    const commentId = parseInt(process.env.CLAUDE_COMMENT_ID!);
+    const githubToken = process.env.GITHUB_TOKEN!;
+    const claudeBranch = process.env.CLAUDE_BRANCH;
+    const baseBranch = process.env.BASE_BRANCH || "main";
+    const triggerUsername = process.env.TRIGGER_USERNAME;
+
+    const context = parseGitHubContext();
+
+    // This script is only called for entity-based events
+    if (!isEntityContext(context)) {
+      throw new Error("update-comment-link requires an entity context");
+    }
+
+    const { owner, repo } = context.repository;
+
+    const octokit = createOctokit(githubToken);
+
+    const serverUrl = GITHUB_SERVER_URL;
+    const jobUrl = `${serverUrl}/${owner}/${repo}/actions/runs/${process.env.GITHUB_RUN_ID}`;
+
+    let comment;
+    let isPRReviewComment = false;
+
+    try {
+      // GitHub has separate ID namespaces for review comments and issue comments
+      // We need to use the correct API based on the event type
+      if (isPullRequestReviewCommentEvent(context)) {
+        // For PR review comments, use the pulls API
+        console.log(`Fetching PR review comment ${commentId}`);
+        const { data: prComment } = await octokit.rest.pulls.getReviewComment({
+          owner,
+          repo,
+          comment_id: commentId,
+        });
+        comment = prComment;
+        isPRReviewComment = true;
+        console.log("Successfully fetched as PR review comment");
+      }
+
+      // For all other event types, use the issues API
+      if (!comment) {
+        console.log(`Fetching issue comment ${commentId}`);
+        const { data: issueComment } = await octokit.rest.issues.getComment({
+          owner,
+          repo,
+          comment_id: commentId,
+        });
+        comment = issueComment;
+        isPRReviewComment = false;
+        console.log("Successfully fetched as issue comment");
+      }
+    } catch (finalError) {
+      // If all attempts fail, try to determine more information about the comment
+      console.error("Failed to fetch comment. Debug info:");
+      console.error(`Comment ID: ${commentId}`);
+      console.error(`Event name: ${context.eventName}`);
+      console.error(`Entity number: ${context.entityNumber}`);
+      console.error(`Repository: ${context.repository.full_name}`);
+
+      // Try to get the PR info to understand the comment structure
+      try {
+        const { data: pr } = await octokit.rest.pulls.get({
+          owner,
+          repo,
+          pull_number: context.entityNumber,
+        });
+        console.log(`PR state: ${pr.state}`);
+        console.log(`PR comments count: ${pr.comments}`);
+        console.log(`PR review comments count: ${pr.review_comments}`);
+      } catch {
+        console.error("Could not fetch PR info for debugging");
+      }
+
+      throw finalError;
+    }
+
+    const currentBody = comment.body ?? "";
+
+    // Check if we need to add branch link for new branches
+    const useCommitSigning = process.env.USE_COMMIT_SIGNING === "true";
+    const { shouldDeleteBranch, branchLink } =
+      await checkAndCommitOrDeleteBranch(
+        octokit,
+        owner,
+        repo,
+        claudeBranch,
+        baseBranch,
+        useCommitSigning,
+      );
+
+    // Check if we need to add PR URL when we have a new branch
+    let prLink = "";
+    // If claudeBranch is set, it means we created a new branch (for issues or closed/merged PRs)
+    if (claudeBranch && !shouldDeleteBranch) {
+      // Check if comment already contains a PR URL
+      const serverUrlPattern = serverUrl.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const prUrlPattern = new RegExp(
+        `${serverUrlPattern}\\/.+\\/compare\\/${baseBranch.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\.\\.\\.`,
+      );
+      const containsPRUrl = currentBody.match(prUrlPattern);
+
+      if (!containsPRUrl) {
+        // Check if there are changes to the branch compared to the default branch
+        try {
+          const { data: comparison } =
+            await octokit.rest.repos.compareCommitsWithBasehead({
+              owner,
+              repo,
+              basehead: `${baseBranch}...${claudeBranch}`,
+            });
+
+          // If there are changes (commits or file changes), add the PR URL
+          if (
+            comparison.total_commits > 0 ||
+            (comparison.files && comparison.files.length > 0)
+          ) {
+            const entityType = context.isPR ? "PR" : "Issue";
+            const prTitle = encodeURIComponent(
+              `${entityType} #${context.entityNumber}: Changes from Claude`,
+            );
+            const prBody = encodeURIComponent(
+              `This PR addresses ${entityType.toLowerCase()} #${context.entityNumber}\n\nGenerated with [Claude Code](https://claude.ai/code)`,
+            );
+            const prUrl = `${serverUrl}/${owner}/${repo}/compare/${baseBranch}...${claudeBranch}?quick_pull=1&title=${prTitle}&body=${prBody}`;
+            prLink = `\n[Create a PR](${prUrl})`;
+          }
+        } catch (error) {
+          console.error("Error checking for changes in branch:", error);
+          // Don't fail the entire update if we can't check for changes
+        }
+      }
+    }
+
+    // Check if action failed and read output file for execution details
+    let executionDetails: {
+      cost_usd?: number;
+      duration_ms?: number;
+      duration_api_ms?: number;
+    } | null = null;
+    let actionFailed = false;
+    let errorDetails: string | undefined;
+
+    // First check if prepare step failed
+    const prepareSuccess = process.env.PREPARE_SUCCESS !== "false";
+    const prepareError = process.env.PREPARE_ERROR;
+
+    if (!prepareSuccess && prepareError) {
+      actionFailed = true;
+      errorDetails = prepareError;
+    } else {
+      // Check for existence of output file and parse it if available
+      try {
+        const outputFile = process.env.OUTPUT_FILE;
+        if (outputFile) {
+          const fileContent = await fs.readFile(outputFile, "utf8");
+          const outputData = JSON.parse(fileContent);
+
+          // Output file is an array, get the last element which contains execution details
+          if (Array.isArray(outputData) && outputData.length > 0) {
+            const lastElement = outputData[outputData.length - 1];
+            if (
+              lastElement.type === "result" &&
+              "cost_usd" in lastElement &&
+              "duration_ms" in lastElement
+            ) {
+              executionDetails = {
+                cost_usd: lastElement.cost_usd,
+                duration_ms: lastElement.duration_ms,
+                duration_api_ms: lastElement.duration_api_ms,
+              };
+            }
+          }
+        }
+
+        // Check if the Claude action failed
+        const claudeSuccess = process.env.CLAUDE_SUCCESS !== "false";
+        actionFailed = !claudeSuccess;
+      } catch (error) {
+        console.error("Error reading output file:", error);
+        // If we can't read the file, check for any failure markers
+        actionFailed = process.env.CLAUDE_SUCCESS === "false";
+      }
+    }
+
+    // Prepare input for updateCommentBody function
+    const commentInput: CommentUpdateInput = {
+      currentBody,
+      actionFailed,
+      executionDetails,
+      jobUrl,
+      branchLink,
+      prLink,
+      branchName: shouldDeleteBranch || !branchLink ? undefined : claudeBranch,
+      triggerUsername,
+      errorDetails,
+    };
+
+    const updatedBody = updateCommentBody(commentInput);
+
+    try {
+      await updateClaudeComment(octokit.rest, {
+        owner,
+        repo,
+        commentId,
+        body: updatedBody,
+        isPullRequestReviewComment: isPRReviewComment,
+      });
+      console.log(
+        `✅ Updated ${isPRReviewComment ? "PR review" : "issue"} comment ${commentId} with job link`,
+      );
+    } catch (updateError) {
+      console.error(
+        `Failed to update ${isPRReviewComment ? "PR review" : "issue"} comment:`,
+        updateError,
+      );
+      throw updateError;
+    }
+
+    process.exit(0);
+  } catch (error) {
+    console.error("Error updating comment with job link:", error);
+    process.exit(1);
+  }
+}
+
+run();

package/bin/_internal/integrations/github/claude-code-action/src/github/api/client.ts

@@ -0,0 +1,23 @@
+import { Octokit } from "@octokit/rest";
+import { graphql } from "@octokit/graphql";
+import { GITHUB_API_URL } from "./config";
+
+export type Octokits = {
+  rest: Octokit;
+  graphql: typeof graphql;
+};
+
+export function createOctokit(token: string): Octokits {
+  return {
+    rest: new Octokit({
+      auth: token,
+      baseUrl: GITHUB_API_URL,
+    }),
+    graphql: graphql.defaults({
+      baseUrl: GITHUB_API_URL,
+      headers: {
+        authorization: `token ${token}`,
+      },
+    }),
+  };
+}

package/bin/_internal/integrations/github/claude-code-action/src/github/api/config.ts

@@ -0,0 +1,4 @@
+export const GITHUB_API_URL =
+  process.env.GITHUB_API_URL || "https://api.github.com";
+export const GITHUB_SERVER_URL =
+  process.env.GITHUB_SERVER_URL || "https://github.com";

package/bin/_internal/integrations/github/claude-code-action/src/github/api/queries/github.ts

@@ -0,0 +1,117 @@
+// GraphQL queries for GitHub data
+
+export const PR_QUERY = `
+  query($owner: String!, $repo: String!, $number: Int!) {
+    repository(owner: $owner, name: $repo) {
+      pullRequest(number: $number) {
+        title
+        body
+        author {
+          login
+        }
+        baseRefName
+        headRefName
+        headRefOid
+        createdAt
+        additions
+        deletions
+        state
+        commits(first: 100) {
+          totalCount
+          nodes {
+            commit {
+              oid
+              message
+              author {
+                name
+                email
+              }
+            }
+          }
+        }
+        files(first: 100) {
+          nodes {
+            path
+            additions
+            deletions
+            changeType
+          }
+        }
+        comments(first: 100) {
+          nodes {
+            id
+            databaseId
+            body
+            author {
+              login
+            }
+            createdAt
+            isMinimized
+          }
+        }
+        reviews(first: 100) {
+          nodes {
+            id
+            databaseId
+            author {
+              login
+            }
+            body
+            state
+            submittedAt
+            comments(first: 100) {
+              nodes {
+                id
+                databaseId
+                body
+                path
+                line
+                author {
+                  login
+                }
+                createdAt
+                isMinimized
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+
+export const ISSUE_QUERY = `
+  query($owner: String!, $repo: String!, $number: Int!) {
+    repository(owner: $owner, name: $repo) {
+      issue(number: $number) {
+        title
+        body
+        author {
+          login
+        }
+        createdAt
+        state
+        comments(first: 100) {
+          nodes {
+            id
+            databaseId
+            body
+            author {
+              login
+            }
+            createdAt
+            isMinimized
+          }
+        }
+      }
+    }
+  }
+`;
+
+export const USER_QUERY = `
+  query($login: String!) {
+    user(login: $login) {
+      name
+    }
+  }
+`;