@vicoa/cli 1.4.2-win32-x64 → 1.4.2

package/bin/_internal/integrations/github/claude-code-action/src/create-prompt/types.ts

@@ -1,102 +0,0 @@
-export type CommonFields = {
-  repository: string;
-  claudeCommentId: string;
-  triggerPhrase: string;
-  triggerUsername?: string;
-  prompt?: string;
-  claudeBranch?: string;
-};
-
-type PullRequestReviewCommentEvent = {
-  eventName: "pull_request_review_comment";
-  isPR: true;
-  prNumber: string;
-  commentId?: string; // May be present for review comments
-  commentBody: string;
-  claudeBranch?: string;
-  baseBranch?: string;
-};
-
-type PullRequestReviewEvent = {
-  eventName: "pull_request_review";
-  isPR: true;
-  prNumber: string;
-  commentBody: string;
-  claudeBranch?: string;
-  baseBranch?: string;
-};
-
-type IssueCommentEvent = {
-  eventName: "issue_comment";
-  commentId: string;
-  issueNumber: string;
-  isPR: false;
-  baseBranch: string;
-  claudeBranch: string;
-  commentBody: string;
-};
-
-// Not actually a real github event, since issue comments and PR coments are both sent as issue_comment
-type PullRequestCommentEvent = {
-  eventName: "issue_comment";
-  commentId: string;
-  prNumber: string;
-  isPR: true;
-  commentBody: string;
-  claudeBranch?: string;
-  baseBranch?: string;
-};
-
-type IssueOpenedEvent = {
-  eventName: "issues";
-  eventAction: "opened";
-  isPR: false;
-  issueNumber: string;
-  baseBranch: string;
-  claudeBranch: string;
-};
-
-type IssueAssignedEvent = {
-  eventName: "issues";
-  eventAction: "assigned";
-  isPR: false;
-  issueNumber: string;
-  baseBranch: string;
-  claudeBranch: string;
-  assigneeTrigger?: string;
-};
-
-type IssueLabeledEvent = {
-  eventName: "issues";
-  eventAction: "labeled";
-  isPR: false;
-  issueNumber: string;
-  baseBranch: string;
-  claudeBranch: string;
-  labelTrigger: string;
-};
-
-type PullRequestEvent = {
-  eventName: "pull_request";
-  eventAction?: string; // opened, synchronize, etc.
-  isPR: true;
-  prNumber: string;
-  claudeBranch?: string;
-  baseBranch?: string;
-};
-
-// Union type for all possible event types
-export type EventData =
-  | PullRequestReviewCommentEvent
-  | PullRequestReviewEvent
-  | PullRequestCommentEvent
-  | IssueCommentEvent
-  | IssueOpenedEvent
-  | IssueAssignedEvent
-  | IssueLabeledEvent
-  | PullRequestEvent;
-
-// Combined type with separate eventData field
-export type PreparedContext = CommonFields & {
-  eventData: EventData;
-};

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

@@ -1,58 +0,0 @@
-import * as core from "@actions/core";
-
-export function collectActionInputsPresence(): void {
-  const inputDefaults: Record<string, string> = {
-    trigger_phrase: "@claude",
-    assignee_trigger: "",
-    label_trigger: "claude",
-    base_branch: "",
-    branch_prefix: "claude/",
-    allowed_bots: "",
-    mode: "tag",
-    model: "",
-    anthropic_model: "",
-    fallback_model: "",
-    allowed_tools: "",
-    disallowed_tools: "",
-    custom_instructions: "",
-    direct_prompt: "",
-    override_prompt: "",
-    additional_permissions: "",
-    claude_env: "",
-    settings: "",
-    anthropic_api_key: "",
-    claude_code_oauth_token: "",
-    github_token: "",
-    max_turns: "",
-    use_sticky_comment: "false",
-    use_commit_signing: "false",
-    experimental_allowed_domains: "",
-  };
-
-  const allInputsJson = process.env.ALL_INPUTS;
-  if (!allInputsJson) {
-    console.log("ALL_INPUTS environment variable not found");
-    core.setOutput("action_inputs_present", JSON.stringify({}));
-    return;
-  }
-
-  let allInputs: Record<string, string>;
-  try {
-    allInputs = JSON.parse(allInputsJson);
-  } catch (e) {
-    console.error("Failed to parse ALL_INPUTS JSON:", e);
-    core.setOutput("action_inputs_present", JSON.stringify({}));
-    return;
-  }
-
-  const presentInputs: Record<string, boolean> = {};
-
-  for (const [name, defaultValue] of Object.entries(inputDefaults)) {
-    const actualValue = allInputs[name] || "";
-
-    const isSet = actualValue !== defaultValue;
-    presentInputs[name] = isSet;
-  }
-
-  core.setOutput("action_inputs_present", JSON.stringify(presentInputs));
-}

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

@@ -1,465 +0,0 @@
-#!/usr/bin/env bun
-
-import { readFileSync, existsSync } from "fs";
-import { exit } from "process";
-
-export type ToolUse = {
-  type: string;
-  name?: string;
-  input?: Record<string, any>;
-  id?: string;
-};
-
-export type ToolResult = {
-  type: string;
-  tool_use_id?: string;
-  content?: any;
-  is_error?: boolean;
-};
-
-export type ContentItem = {
-  type: string;
-  text?: string;
-  tool_use_id?: string;
-  content?: any;
-  is_error?: boolean;
-  name?: string;
-  input?: Record<string, any>;
-  id?: string;
-};
-
-export type Message = {
-  content: ContentItem[];
-  usage?: {
-    input_tokens?: number;
-    output_tokens?: number;
-  };
-};
-
-export type Turn = {
-  type: string;
-  subtype?: string;
-  message?: Message;
-  tools?: any[];
-  cost_usd?: number;
-  duration_ms?: number;
-  result?: string;
-};
-
-export type GroupedContent = {
-  type: string;
-  tools_count?: number;
-  data?: Turn;
-  text_parts?: string[];
-  tool_calls?: { tool_use: ToolUse; tool_result?: ToolResult }[];
-  usage?: Record<string, number>;
-};
-
-export function detectContentType(content: any): string {
-  const contentStr = String(content).trim();
-
-  // Check for JSON
-  if (contentStr.startsWith("{") && contentStr.endsWith("}")) {
-    try {
-      JSON.parse(contentStr);
-      return "json";
-    } catch {
-      // Fall through
-    }
-  }
-
-  if (contentStr.startsWith("[") && contentStr.endsWith("]")) {
-    try {
-      JSON.parse(contentStr);
-      return "json";
-    } catch {
-      // Fall through
-    }
-  }
-
-  // Check for code-like content
-  const codeKeywords = [
-    "def ",
-    "class ",
-    "import ",
-    "from ",
-    "function ",
-    "const ",
-    "let ",
-    "var ",
-  ];
-  if (codeKeywords.some((keyword) => contentStr.includes(keyword))) {
-    if (
-      contentStr.includes("def ") ||
-      contentStr.includes("import ") ||
-      contentStr.includes("from ")
-    ) {
-      return "python";
-    } else if (
-      ["function ", "const ", "let ", "var ", "=>"].some((js) =>
-        contentStr.includes(js),
-      )
-    ) {
-      return "javascript";
-    } else {
-      return "python"; // default for code
-    }
-  }
-
-  // Check for shell/bash output
-  const shellIndicators = ["ls -", "cd ", "mkdir ", "rm ", "$ ", "# "];
-  if (
-    contentStr.startsWith("/") ||
-    contentStr.includes("Error:") ||
-    contentStr.startsWith("total ") ||
-    shellIndicators.some((indicator) => contentStr.includes(indicator))
-  ) {
-    return "bash";
-  }
-
-  // Check for diff format
-  if (
-    contentStr.startsWith("@@") ||
-    contentStr.includes("+++ ") ||
-    contentStr.includes("--- ")
-  ) {
-    return "diff";
-  }
-
-  // Check for HTML/XML
-  if (contentStr.startsWith("<") && contentStr.endsWith(">")) {
-    return "html";
-  }
-
-  // Check for markdown
-  const mdIndicators = ["# ", "## ", "### ", "- ", "* ", "```"];
-  if (mdIndicators.some((indicator) => contentStr.includes(indicator))) {
-    return "markdown";
-  }
-
-  // Default to plain text
-  return "text";
-}
-
-export function formatResultContent(content: any): string {
-  if (!content) {
-    return "*(No output)*\n\n";
-  }
-
-  let contentStr: string;
-
-  // Check if content is a list with "type": "text" structure
-  try {
-    let parsedContent: any;
-    if (typeof content === "string") {
-      parsedContent = JSON.parse(content);
-    } else {
-      parsedContent = content;
-    }
-
-    if (
-      Array.isArray(parsedContent) &&
-      parsedContent.length > 0 &&
-      typeof parsedContent[0] === "object" &&
-      parsedContent[0]?.type === "text"
-    ) {
-      // Extract the text field from the first item
-      contentStr = parsedContent[0]?.text || "";
-    } else {
-      contentStr = String(content).trim();
-    }
-  } catch {
-    contentStr = String(content).trim();
-  }
-
-  // Truncate very long results
-  if (contentStr.length > 3000) {
-    contentStr = contentStr.substring(0, 2997) + "...";
-  }
-
-  // Detect content type
-  const contentType = detectContentType(contentStr);
-
-  // Handle JSON content specially - pretty print it
-  if (contentType === "json") {
-    try {
-      // Try to parse and pretty print JSON
-      const parsed = JSON.parse(contentStr);
-      contentStr = JSON.stringify(parsed, null, 2);
-    } catch {
-      // Keep original if parsing fails
-    }
-  }
-
-  // Format with appropriate syntax highlighting
-  if (
-    contentType === "text" &&
-    contentStr.length < 100 &&
-    !contentStr.includes("\n")
-  ) {
-    // Short text results don't need code blocks
-    return `**→** ${contentStr}\n\n`;
-  } else {
-    return `**Result:**\n\`\`\`${contentType}\n${contentStr}\n\`\`\`\n\n`;
-  }
-}
-
-export function formatToolWithResult(
-  toolUse: ToolUse,
-  toolResult?: ToolResult,
-): string {
-  const toolName = toolUse.name || "unknown_tool";
-  const toolInput = toolUse.input || {};
-
-  let result = `### 🔧 \`${toolName}\`\n\n`;
-
-  // Add parameters if they exist and are not empty
-  if (Object.keys(toolInput).length > 0) {
-    result += "**Parameters:**\n```json\n";
-    result += JSON.stringify(toolInput, null, 2);
-    result += "\n```\n\n";
-  }
-
-  // Add result if available
-  if (toolResult) {
-    const content = toolResult.content || "";
-    const isError = toolResult.is_error || false;
-
-    if (isError) {
-      result += `❌ **Error:** \`${content}\`\n\n`;
-    } else {
-      result += formatResultContent(content);
-    }
-  }
-
-  return result;
-}
-
-export function groupTurnsNaturally(data: Turn[]): GroupedContent[] {
-  const groupedContent: GroupedContent[] = [];
-  const toolResultsMap = new Map<string, ToolResult>();
-
-  // First pass: collect all tool results by tool_use_id
-  for (const turn of data) {
-    if (turn.type === "user") {
-      const content = turn.message?.content || [];
-      for (const item of content) {
-        if (item.type === "tool_result" && item.tool_use_id) {
-          toolResultsMap.set(item.tool_use_id, {
-            type: item.type,
-            tool_use_id: item.tool_use_id,
-            content: item.content,
-            is_error: item.is_error,
-          });
-        }
-      }
-    }
-  }
-
-  // Second pass: process turns and group naturally
-  for (const turn of data) {
-    const turnType = turn.type || "unknown";
-
-    if (turnType === "system") {
-      const subtype = turn.subtype || "";
-      if (subtype === "init") {
-        const tools = turn.tools || [];
-        groupedContent.push({
-          type: "system_init",
-          tools_count: tools.length,
-        });
-      } else {
-        groupedContent.push({
-          type: "system_other",
-          data: turn,
-        });
-      }
-    } else if (turnType === "assistant") {
-      const message = turn.message || { content: [] };
-      const content = message.content || [];
-      const usage = message.usage || {};
-
-      // Process content items
-      const textParts: string[] = [];
-      const toolCalls: { tool_use: ToolUse; tool_result?: ToolResult }[] = [];
-
-      for (const item of content) {
-        const itemType = item.type || "";
-
-        if (itemType === "text") {
-          textParts.push(item.text || "");
-        } else if (itemType === "tool_use") {
-          const toolUseId = item.id;
-          const toolResult = toolUseId
-            ? toolResultsMap.get(toolUseId)
-            : undefined;
-          toolCalls.push({
-            tool_use: {
-              type: item.type,
-              name: item.name,
-              input: item.input,
-              id: item.id,
-            },
-            tool_result: toolResult,
-          });
-        }
-      }
-
-      if (textParts.length > 0 || toolCalls.length > 0) {
-        groupedContent.push({
-          type: "assistant_action",
-          text_parts: textParts,
-          tool_calls: toolCalls,
-          usage: usage,
-        });
-      }
-    } else if (turnType === "user") {
-      // Handle user messages that aren't tool results
-      const message = turn.message || { content: [] };
-      const content = message.content || [];
-      const textParts: string[] = [];
-
-      for (const item of content) {
-        if (item.type === "text") {
-          textParts.push(item.text || "");
-        }
-      }
-
-      if (textParts.length > 0) {
-        groupedContent.push({
-          type: "user_message",
-          text_parts: textParts,
-        });
-      }
-    } else if (turnType === "result") {
-      groupedContent.push({
-        type: "final_result",
-        data: turn,
-      });
-    }
-  }
-
-  return groupedContent;
-}
-
-export function formatGroupedContent(groupedContent: GroupedContent[]): string {
-  let markdown = "## Claude Code Report\n\n";
-
-  for (const item of groupedContent) {
-    const itemType = item.type;
-
-    if (itemType === "system_init") {
-      markdown += `## 🚀 System Initialization\n\n**Available Tools:** ${item.tools_count} tools loaded\n\n---\n\n`;
-    } else if (itemType === "system_other") {
-      markdown += `## ⚙️ System Message\n\n${JSON.stringify(item.data, null, 2)}\n\n---\n\n`;
-    } else if (itemType === "assistant_action") {
-      // Add text content first (if any) - no header needed
-      for (const text of item.text_parts || []) {
-        if (text.trim()) {
-          markdown += `${text}\n\n`;
-        }
-      }
-
-      // Add tool calls with their results
-      for (const toolCall of item.tool_calls || []) {
-        markdown += formatToolWithResult(
-          toolCall.tool_use,
-          toolCall.tool_result,
-        );
-      }
-
-      // Add usage info if available
-      const usage = item.usage || {};
-      if (Object.keys(usage).length > 0) {
-        const inputTokens = usage.input_tokens || 0;
-        const cacheCreationTokens = usage.cache_creation_input_tokens || 0;
-        const cacheReadTokens = usage.cache_read_input_tokens || 0;
-        const totalInputTokens =
-          inputTokens + cacheCreationTokens + cacheReadTokens;
-        const outputTokens = usage.output_tokens || 0;
-        markdown += `*Token usage: ${totalInputTokens} input, ${outputTokens} output*\n\n`;
-      }
-
-      // Only add separator if this section had content
-      if (
-        (item.text_parts && item.text_parts.length > 0) ||
-        (item.tool_calls && item.tool_calls.length > 0)
-      ) {
-        markdown += "---\n\n";
-      }
-    } else if (itemType === "user_message") {
-      markdown += "## 👤 User\n\n";
-      for (const text of item.text_parts || []) {
-        if (text.trim()) {
-          markdown += `${text}\n\n`;
-        }
-      }
-      markdown += "---\n\n";
-    } else if (itemType === "final_result") {
-      const data = item.data || {};
-      const cost = (data as any).total_cost_usd || (data as any).cost_usd || 0;
-      const duration = (data as any).duration_ms || 0;
-      const resultText = (data as any).result || "";
-
-      markdown += "## ✅ Final Result\n\n";
-      if (resultText) {
-        markdown += `${resultText}\n\n`;
-      }
-      markdown += `**Cost:** $${cost.toFixed(4)} | **Duration:** ${(duration / 1000).toFixed(1)}s\n\n`;
-    }
-  }
-
-  return markdown;
-}
-
-export function formatTurnsFromData(data: Turn[]): string {
-  // Group turns naturally
-  const groupedContent = groupTurnsNaturally(data);
-
-  // Generate markdown
-  const markdown = formatGroupedContent(groupedContent);
-
-  return markdown;
-}
-
-function main(): void {
-  // Get the JSON file path from command line arguments
-  const args = process.argv.slice(2);
-  if (args.length === 0) {
-    console.error("Usage: format-turns.ts <json-file>");
-    exit(1);
-  }
-
-  const jsonFile = args[0];
-  if (!jsonFile) {
-    console.error("Error: No JSON file provided");
-    exit(1);
-  }
-
-  if (!existsSync(jsonFile)) {
-    console.error(`Error: ${jsonFile} not found`);
-    exit(1);
-  }
-
-  try {
-    // Read the JSON file
-    const fileContent = readFileSync(jsonFile, "utf-8");
-    const data: Turn[] = JSON.parse(fileContent);
-
-    // Group turns naturally
-    const groupedContent = groupTurnsNaturally(data);
-
-    // Generate markdown
-    const markdown = formatGroupedContent(groupedContent);
-
-    // Print to stdout (so it can be captured by shell)
-    console.log(markdown);
-  } catch (error) {
-    console.error(`Error processing file: ${error}`);
-    exit(1);
-  }
-}
-
-if (import.meta.main) {
-  main();
-}