@juspay/neurolink 8.32.0 → 8.34.0

package/dist/action/actionExecutor.js

@@ -0,0 +1,290 @@
+// src/lib/action/actionExecutor.ts
+/**
+ * CLI execution for GitHub Action
+ * @module action/actionExecutor
+ */
+import * as exec from "@actions/exec";
+import * as core from "@actions/core";
+import * as fs from "fs";
+import * as path from "path";
+import { buildEnvironmentVariables } from "./actionInputs.js";
+import { withTimeout } from "../utils/errorHandling.js";
+/** Default timeout for CLI execution (5 minutes) */
+const DEFAULT_EXECUTION_TIMEOUT_MS = 300000;
+/**
+ * Transform CLI token usage format to action format
+ */
+function transformTokenUsage(cliUsage) {
+    if (!cliUsage) {
+        return undefined;
+    }
+    return {
+        promptTokens: cliUsage.input,
+        completionTokens: cliUsage.output,
+        totalTokens: cliUsage.total,
+    };
+}
+/**
+ * Transform CLI evaluation format to action format (scale 1-10 to 0-100)
+ */
+function transformEvaluation(cliEval) {
+    if (!cliEval) {
+        return undefined;
+    }
+    return {
+        overallScore: cliEval.overall * 10, // Scale to 0-100
+        relevance: cliEval.relevance,
+        accuracy: cliEval.accuracy,
+        completeness: cliEval.completeness,
+    };
+}
+/**
+ * Transform CLI response to action result format
+ */
+export function transformCliResponse(cliResponse) {
+    return {
+        response: cliResponse.content,
+        responseJson: cliResponse,
+        // Use top-level provider/model if available, otherwise fallback to analytics
+        provider: cliResponse.provider || cliResponse.analytics?.provider,
+        model: cliResponse.model || cliResponse.analytics?.model,
+        usage: transformTokenUsage(cliResponse.usage),
+        cost: cliResponse.analytics?.cost,
+        executionTime: cliResponse.responseTime,
+        evaluation: transformEvaluation(cliResponse.evaluation),
+    };
+}
+/**
+ * Build CLI arguments from action inputs (using verified camelCase flags)
+ */
+export function buildCliArgs(inputs) {
+    const args = [inputs.command, inputs.prompt];
+    // Provider & Model
+    if (inputs.provider && inputs.provider !== "auto") {
+        args.push("--provider", inputs.provider);
+    }
+    if (inputs.model) {
+        args.push("--model", inputs.model);
+    }
+    // Generation parameters (camelCase flags!)
+    if (inputs.temperature !== undefined) {
+        args.push("--temperature", inputs.temperature.toString());
+    }
+    if (inputs.maxTokens !== undefined) {
+        args.push("--maxTokens", inputs.maxTokens.toString()); // NOT --max-tokens
+    }
+    if (inputs.systemPrompt) {
+        args.push("--system", inputs.systemPrompt);
+    }
+    // Output format (always JSON for parsing)
+    args.push("--format", "json");
+    args.push("--quiet");
+    args.push("--noColor");
+    // Multimodal inputs
+    const { multimodal } = inputs;
+    if (multimodal.imagePaths) {
+        for (const img of multimodal.imagePaths) {
+            args.push("--image", img);
+        }
+    }
+    if (multimodal.pdfPaths) {
+        for (const pdf of multimodal.pdfPaths) {
+            args.push("--pdf", pdf);
+        }
+    }
+    if (multimodal.csvPaths) {
+        for (const csv of multimodal.csvPaths) {
+            args.push("--csv", csv);
+        }
+    }
+    if (multimodal.videoPaths) {
+        for (const video of multimodal.videoPaths) {
+            args.push("--video", video);
+        }
+    }
+    // Extended thinking (camelCase flags!)
+    if (inputs.thinking.enabled) {
+        args.push("--thinking");
+        args.push("--thinkingLevel", inputs.thinking.level); // NOT --thinking-level
+        args.push("--thinkingBudget", inputs.thinking.budget.toString()); // NOT --thinking-budget
+    }
+    // Features (camelCase flags!)
+    if (inputs.enableAnalytics) {
+        args.push("--enableAnalytics"); // NOT --enable-analytics
+    }
+    if (inputs.enableEvaluation) {
+        args.push("--enableEvaluation"); // NOT --enable-evaluation
+    }
+    // Timeout
+    if (inputs.timeout) {
+        args.push("--timeout", inputs.timeout.toString());
+    }
+    // Output file
+    if (inputs.outputFile) {
+        args.push("--output", inputs.outputFile);
+    }
+    // Debug
+    if (inputs.debug) {
+        args.push("--debug");
+    }
+    return args;
+}
+/**
+ * Install NeuroLink CLI
+ */
+export async function installNeurolink(version) {
+    core.info(`Installing @juspay/neurolink@${version}...`);
+    const installArgs = version === "latest"
+        ? ["install", "-g", "@juspay/neurolink"]
+        : ["install", "-g", `@juspay/neurolink@${version}`];
+    await exec.exec("npm", installArgs, {
+        silent: !core.isDebug(),
+    });
+    core.info("NeuroLink CLI installed successfully");
+}
+/**
+ * Execute NeuroLink CLI command
+ * @param args - CLI arguments
+ * @param env - Environment variables
+ * @param workingDirectory - Working directory for execution
+ * @param timeout - Timeout in milliseconds (defaults to 5 minutes)
+ */
+export async function executeNeurolink(args, env, workingDirectory, timeout = DEFAULT_EXECUTION_TIMEOUT_MS) {
+    const startTime = Date.now();
+    try {
+        // Filter out undefined values from process.env
+        const processEnv = {};
+        for (const [key, value] of Object.entries(process.env)) {
+            if (value !== undefined) {
+                processEnv[key] = value;
+            }
+        }
+        const execPromise = exec.getExecOutput("neurolink", args, {
+            cwd: workingDirectory,
+            env: { ...processEnv, ...env },
+            silent: false,
+            ignoreReturnCode: true,
+        });
+        // Wrap execution with timeout protection
+        const { exitCode, stdout, stderr } = await withTimeout(execPromise, timeout, new Error(`CLI execution timed out after ${timeout}ms. Consider increasing the timeout parameter.`));
+        const executionTime = Date.now() - startTime;
+        if (exitCode !== 0) {
+            return {
+                success: false,
+                response: "",
+                error: stderr || `CLI exited with code ${exitCode}`,
+                executionTime,
+            };
+        }
+        // Parse JSON output
+        try {
+            // The CLI output may have log lines before the JSON
+            // The CLI JSON response always has "content" as the first key
+            // Find the line that contains '{"content"' or '{ "content"' to locate JSON start
+            const lines = stdout.split("\n");
+            let jsonStartIndex = -1;
+            // Find the line that starts the JSON response object
+            // Look for pattern: line is "{" and next non-empty line has "content"
+            for (let i = 0; i < lines.length; i++) {
+                const trimmedLine = lines[i].trim();
+                if (trimmedLine === "{") {
+                    // Check if next non-empty line contains "content"
+                    for (let j = i + 1; j < lines.length && j < i + 3; j++) {
+                        const nextLine = lines[j].trim();
+                        if (nextLine.includes('"content"')) {
+                            jsonStartIndex = i;
+                            break;
+                        }
+                    }
+                    if (jsonStartIndex !== -1) {
+                        break;
+                    }
+                }
+            }
+            core.debug(`JSON start line index: ${jsonStartIndex}`);
+            if (jsonStartIndex === -1) {
+                core.debug("No JSON found, returning raw stdout");
+                return {
+                    success: true,
+                    response: stdout.trim(),
+                    executionTime,
+                };
+            }
+            // Extract JSON from that line onwards
+            const jsonStr = lines.slice(jsonStartIndex).join("\n").trim();
+            core.debug(`JSON string starts with: ${jsonStr.substring(0, 50)}`);
+            const cliResponse = JSON.parse(jsonStr);
+            core.debug(`Parsed CLI response keys: ${Object.keys(cliResponse).join(", ")}`);
+            core.debug(`cliResponse.content: ${cliResponse.content?.substring(0, 50)}`);
+            core.debug(`cliResponse.provider: ${cliResponse.provider}`);
+            const transformed = transformCliResponse(cliResponse);
+            core.debug(`Transformed response: ${transformed.response?.substring(0, 50)}`);
+            core.debug(`Transformed provider: ${transformed.provider}`);
+            return {
+                success: true,
+                ...transformed,
+                executionTime: transformed.executionTime || executionTime,
+            };
+        }
+        catch (parseError) {
+            // If not JSON, return raw output
+            core.debug(`JSON parse error: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+            return {
+                success: true,
+                response: stdout.trim(),
+                executionTime,
+            };
+        }
+    }
+    catch (error) {
+        return {
+            success: false,
+            response: "",
+            error: error instanceof Error ? error.message : String(error),
+            executionTime: Date.now() - startTime,
+        };
+    }
+}
+/**
+ * Run complete NeuroLink action
+ */
+export async function runNeurolink(inputs) {
+    let credPath;
+    try {
+        // Install CLI
+        await installNeurolink(inputs.neurolinkVersion);
+        // Build environment
+        const env = buildEnvironmentVariables(inputs);
+        // Handle Google Cloud credentials (base64 decode)
+        if (inputs.googleCloudConfig.googleApplicationCredentials) {
+            const decoded = Buffer.from(inputs.googleCloudConfig.googleApplicationCredentials, "base64").toString("utf-8");
+            credPath = path.join(process.env.RUNNER_TEMP || "/tmp", `vertex-credentials-${process.pid}-${Date.now()}.json`);
+            fs.writeFileSync(credPath, decoded, { mode: 0o600 });
+            env.GOOGLE_APPLICATION_CREDENTIALS = credPath;
+        }
+        // Build CLI arguments
+        const args = buildCliArgs(inputs);
+        core.info(`Executing: neurolink ${args.join(" ")}`);
+        if (inputs.debug) {
+            core.debug(`Working directory: ${inputs.workingDirectory}`);
+            core.debug(`Environment keys: ${Object.keys(env)
+                .filter((k) => k.includes("API") || k.includes("KEY"))
+                .join(", ")}`);
+        }
+        // Execute with timeout (use input timeout or default)
+        const executionTimeout = inputs.timeout || DEFAULT_EXECUTION_TIMEOUT_MS;
+        return await executeNeurolink(args, env, inputs.workingDirectory, executionTimeout);
+    }
+    finally {
+        // Clean up credential file
+        if (credPath && fs.existsSync(credPath)) {
+            try {
+                fs.unlinkSync(credPath);
+                core.debug("Cleaned up temporary credentials file");
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+    }
+}

package/dist/action/actionInputs.d.ts

@@ -0,0 +1,25 @@
+/**
+ * GitHub Action input parsing and validation
+ * @module action/actionInputs
+ */
+import type { ActionInputs, ActionProviderKeys, ActionInputValidation, ActionAWSConfig, ActionGoogleCloudConfig } from "../types/actionTypes.js";
+/**
+ * Mask all secrets in logs
+ */
+export declare function maskSecrets(inputs: ActionInputs): void;
+/**
+ * Validate that provider has required API key
+ */
+export declare function validateProviderKey(provider: string, keys: Partial<ActionProviderKeys>, awsConfig?: Partial<ActionAWSConfig>, googleConfig?: Partial<ActionGoogleCloudConfig>): boolean;
+/**
+ * Parse all action inputs from GitHub Action context
+ */
+export declare function parseActionInputs(): ActionInputs;
+/**
+ * Build environment variables from action inputs
+ */
+export declare function buildEnvironmentVariables(inputs: ActionInputs): Record<string, string>;
+/**
+ * Validate all action inputs
+ */
+export declare function validateActionInputs(inputs: ActionInputs): ActionInputValidation;

package/dist/action/actionInputs.js

@@ -0,0 +1,293 @@
+// src/lib/action/actionInputs.ts
+/**
+ * GitHub Action input parsing and validation
+ * @module action/actionInputs
+ */
+import * as core from "@actions/core";
+import { AIProviderName } from "../constants/enums.js";
+import { ErrorFactory } from "../utils/errorHandling.js";
+const PROVIDER_KEY_MAP = {
+    [AIProviderName.OPENAI]: ["openaiApiKey"],
+    [AIProviderName.ANTHROPIC]: ["anthropicApiKey"],
+    [AIProviderName.GOOGLE_AI]: ["googleAiApiKey"],
+    [AIProviderName.VERTEX]: ["googleVertexProject"],
+    [AIProviderName.BEDROCK]: ["awsAccessKeyId", "awsSecretAccessKey"],
+    [AIProviderName.AZURE]: ["azureOpenaiApiKey", "azureOpenaiEndpoint"],
+    [AIProviderName.MISTRAL]: ["mistralApiKey"],
+    [AIProviderName.HUGGINGFACE]: ["huggingfaceApiKey"],
+    [AIProviderName.OPENROUTER]: ["openrouterApiKey"],
+    [AIProviderName.LITELLM]: ["litellmApiKey", "litellmBaseUrl"],
+    [AIProviderName.SAGEMAKER]: ["awsAccessKeyId", "awsSecretAccessKey"],
+    [AIProviderName.OPENAI_COMPATIBLE]: [
+        "openaiCompatibleApiKey",
+        "openaiCompatibleBaseUrl",
+    ],
+};
+/**
+ * Parse comma-separated paths into array
+ */
+function parsePathList(input) {
+    if (!input) {
+        return undefined;
+    }
+    return input
+        .split(",")
+        .map((p) => p.trim())
+        .filter(Boolean);
+}
+/**
+ * Parse and validate a numeric input, throwing if NaN
+ */
+function parseNumericInput(inputName, rawValue, defaultValue, parseFunction, radix) {
+    if (!rawValue) {
+        return defaultValue;
+    }
+    const parsed = radix !== undefined
+        ? parseFunction(rawValue, radix)
+        : parseFunction(rawValue);
+    if (isNaN(parsed)) {
+        throw ErrorFactory.invalidConfiguration(inputName, `expected a valid number but received "${rawValue}"`);
+    }
+    return parsed;
+}
+/**
+ * Mask all secrets in logs
+ */
+export function maskSecrets(inputs) {
+    const secrets = [
+        inputs.providerKeys.openaiApiKey,
+        inputs.providerKeys.anthropicApiKey,
+        inputs.providerKeys.googleAiApiKey,
+        inputs.providerKeys.azureOpenaiApiKey,
+        inputs.providerKeys.mistralApiKey,
+        inputs.providerKeys.huggingfaceApiKey,
+        inputs.providerKeys.openrouterApiKey,
+        inputs.providerKeys.litellmApiKey,
+        inputs.providerKeys.openaiCompatibleApiKey,
+        inputs.awsConfig.awsAccessKeyId,
+        inputs.awsConfig.awsSecretAccessKey,
+        inputs.awsConfig.awsSessionToken,
+        inputs.googleCloudConfig.googleApplicationCredentials,
+        inputs.githubToken,
+    ];
+    secrets
+        .filter((s) => Boolean(s))
+        .forEach((secret) => core.setSecret(secret));
+}
+/**
+ * Validate that provider has required API key
+ */
+export function validateProviderKey(provider, keys, awsConfig, googleConfig) {
+    // These providers don't require API keys
+    if (provider === "auto" || provider === "ollama") {
+        return true;
+    }
+    const requiredKeys = PROVIDER_KEY_MAP[provider];
+    if (!requiredKeys) {
+        // Log warning for unknown provider, but don't fail (allows new providers)
+        core.warning(`Unknown provider "${provider}" - skipping key validation`);
+        return true;
+    }
+    // Check keys across all config objects
+    return requiredKeys.every((key) => {
+        const keyValue = keys[key] ||
+            awsConfig?.[key] ||
+            googleConfig?.[key];
+        return !!keyValue;
+    });
+}
+/**
+ * Parse all action inputs from GitHub Action context
+ */
+export function parseActionInputs() {
+    const prompt = core.getInput("prompt", { required: true });
+    const provider = core.getInput("provider") || "auto";
+    // Parse provider keys (verified providers only)
+    const providerKeys = {
+        openaiApiKey: core.getInput("openai_api_key") || undefined,
+        anthropicApiKey: core.getInput("anthropic_api_key") || undefined,
+        googleAiApiKey: core.getInput("google_ai_api_key") || undefined,
+        azureOpenaiApiKey: core.getInput("azure_openai_api_key") || undefined,
+        azureOpenaiEndpoint: core.getInput("azure_openai_endpoint") || undefined,
+        azureOpenaiDeployment: core.getInput("azure_openai_deployment") || undefined,
+        mistralApiKey: core.getInput("mistral_api_key") || undefined,
+        huggingfaceApiKey: core.getInput("huggingface_api_key") || undefined,
+        openrouterApiKey: core.getInput("openrouter_api_key") || undefined,
+        litellmApiKey: core.getInput("litellm_api_key") || undefined,
+        litellmBaseUrl: core.getInput("litellm_base_url") || undefined,
+        openaiCompatibleApiKey: core.getInput("openai_compatible_api_key") || undefined,
+        openaiCompatibleBaseUrl: core.getInput("openai_compatible_base_url") || undefined,
+    };
+    // AWS config
+    const awsConfig = {
+        awsAccessKeyId: core.getInput("aws_access_key_id") || undefined,
+        awsSecretAccessKey: core.getInput("aws_secret_access_key") || undefined,
+        awsRegion: core.getInput("aws_region") || "us-east-1",
+        awsSessionToken: core.getInput("aws_session_token") || undefined,
+        bedrockModelId: core.getInput("bedrock_model_id") || undefined,
+        sagemakerEndpoint: core.getInput("sagemaker_endpoint") || undefined,
+    };
+    // Google Cloud config
+    const googleCloudConfig = {
+        googleVertexProject: core.getInput("google_vertex_project") || undefined,
+        googleVertexLocation: core.getInput("google_vertex_location") || "us-central1",
+        googleApplicationCredentials: core.getInput("google_application_credentials") || undefined,
+    };
+    // Validate provider has key
+    if (!validateProviderKey(provider, providerKeys, awsConfig, googleCloudConfig)) {
+        throw ErrorFactory.missingConfiguration(`API key for provider: ${provider}`);
+    }
+    return {
+        prompt,
+        provider: provider,
+        model: core.getInput("model") || undefined,
+        // Generation parameters
+        temperature: parseNumericInput("temperature", core.getInput("temperature"), 0.7, parseFloat),
+        maxTokens: parseNumericInput("max_tokens", core.getInput("max_tokens"), 4096, parseInt, 10),
+        systemPrompt: core.getInput("system_prompt") || undefined,
+        // Command
+        command: (core.getInput("command") || "generate"),
+        // Provider keys
+        providerKeys,
+        // AWS config
+        awsConfig,
+        // Google Cloud config
+        googleCloudConfig,
+        // Multimodal inputs
+        multimodal: {
+            imagePaths: parsePathList(core.getInput("image_paths")),
+            pdfPaths: parsePathList(core.getInput("pdf_paths")),
+            csvPaths: parsePathList(core.getInput("csv_paths")),
+            videoPaths: parsePathList(core.getInput("video_paths")),
+        },
+        // Extended thinking
+        thinking: {
+            enabled: core.getBooleanInput("thinking_enabled"),
+            level: (core.getInput("thinking_level") || "medium"),
+            budget: parseNumericInput("thinking_budget", core.getInput("thinking_budget"), 10000, parseInt, 10),
+        },
+        // Features (verified to exist in CLI)
+        enableAnalytics: core.getBooleanInput("enable_analytics"),
+        enableEvaluation: core.getBooleanInput("enable_evaluation"),
+        // Output
+        outputFormat: (core.getInput("output_format") || "text"),
+        outputFile: core.getInput("output_file") || undefined,
+        // MCP Tools
+        enableTools: core.getBooleanInput("enable_tools"),
+        mcpConfigPath: core.getInput("mcp_config_path") || undefined,
+        // GitHub Integration
+        postComment: core.getBooleanInput("post_comment"),
+        updateExistingComment: core.getBooleanInput("update_existing_comment"),
+        commentTag: core.getInput("comment_tag") || "neurolink-action",
+        githubToken: core.getInput("github_token") || process.env.GITHUB_TOKEN,
+        // Advanced
+        timeout: parseNumericInput("timeout", core.getInput("timeout"), 300, parseInt, 10),
+        debug: core.getBooleanInput("debug"),
+        neurolinkVersion: core.getInput("neurolink_version") || "latest",
+        workingDirectory: core.getInput("working_directory") || ".",
+    };
+}
+/**
+ * Build environment variables from action inputs
+ */
+export function buildEnvironmentVariables(inputs) {
+    const env = {
+        CI: "true",
+        NEUROLINK_NON_INTERACTIVE: "true",
+    };
+    // Provider keys
+    const { providerKeys } = inputs;
+    if (providerKeys.openaiApiKey) {
+        env.OPENAI_API_KEY = providerKeys.openaiApiKey;
+    }
+    if (providerKeys.anthropicApiKey) {
+        env.ANTHROPIC_API_KEY = providerKeys.anthropicApiKey;
+    }
+    if (providerKeys.googleAiApiKey) {
+        env.GOOGLE_AI_API_KEY = providerKeys.googleAiApiKey;
+    }
+    if (providerKeys.azureOpenaiApiKey) {
+        env.AZURE_OPENAI_API_KEY = providerKeys.azureOpenaiApiKey;
+    }
+    if (providerKeys.azureOpenaiEndpoint) {
+        env.AZURE_OPENAI_ENDPOINT = providerKeys.azureOpenaiEndpoint;
+    }
+    if (providerKeys.azureOpenaiDeployment) {
+        env.AZURE_OPENAI_DEPLOYMENT = providerKeys.azureOpenaiDeployment;
+    }
+    if (providerKeys.mistralApiKey) {
+        env.MISTRAL_API_KEY = providerKeys.mistralApiKey;
+    }
+    if (providerKeys.huggingfaceApiKey) {
+        env.HUGGINGFACE_API_KEY = providerKeys.huggingfaceApiKey;
+    }
+    if (providerKeys.openrouterApiKey) {
+        env.OPENROUTER_API_KEY = providerKeys.openrouterApiKey;
+    }
+    if (providerKeys.litellmApiKey) {
+        env.LITELLM_API_KEY = providerKeys.litellmApiKey;
+    }
+    if (providerKeys.litellmBaseUrl) {
+        env.LITELLM_BASE_URL = providerKeys.litellmBaseUrl;
+    }
+    if (providerKeys.openaiCompatibleApiKey) {
+        env.OPENAI_COMPATIBLE_API_KEY = providerKeys.openaiCompatibleApiKey;
+    }
+    if (providerKeys.openaiCompatibleBaseUrl) {
+        env.OPENAI_COMPATIBLE_BASE_URL = providerKeys.openaiCompatibleBaseUrl;
+    }
+    // AWS
+    const { awsConfig } = inputs;
+    if (awsConfig.awsAccessKeyId) {
+        env.AWS_ACCESS_KEY_ID = awsConfig.awsAccessKeyId;
+    }
+    if (awsConfig.awsSecretAccessKey) {
+        env.AWS_SECRET_ACCESS_KEY = awsConfig.awsSecretAccessKey;
+    }
+    env.AWS_REGION = awsConfig.awsRegion;
+    if (awsConfig.awsSessionToken) {
+        env.AWS_SESSION_TOKEN = awsConfig.awsSessionToken;
+    }
+    if (awsConfig.bedrockModelId) {
+        env.BEDROCK_MODEL_ID = awsConfig.bedrockModelId;
+    }
+    if (awsConfig.sagemakerEndpoint) {
+        env.SAGEMAKER_DEFAULT_ENDPOINT = awsConfig.sagemakerEndpoint;
+    }
+    // Google Cloud
+    const { googleCloudConfig } = inputs;
+    if (googleCloudConfig.googleVertexProject) {
+        env.GOOGLE_VERTEX_PROJECT = googleCloudConfig.googleVertexProject;
+    }
+    env.GOOGLE_VERTEX_LOCATION = googleCloudConfig.googleVertexLocation;
+    // GitHub
+    if (inputs.githubToken) {
+        env.GITHUB_TOKEN = inputs.githubToken;
+    }
+    return env;
+}
+/**
+ * Validate all action inputs
+ */
+export function validateActionInputs(inputs) {
+    const errors = [];
+    const warnings = [];
+    // Required fields
+    if (!inputs.prompt) {
+        errors.push("prompt is required");
+    }
+    // Temperature range
+    if (inputs.temperature < 0 || inputs.temperature > 2) {
+        warnings.push("temperature should be between 0 and 2");
+    }
+    // Thinking budget range
+    if (inputs.thinking.enabled &&
+        (inputs.thinking.budget < 5000 || inputs.thinking.budget > 100000)) {
+        warnings.push("thinking_budget should be between 5000 and 100000");
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}

package/dist/action/githubIntegration.d.ts

@@ -0,0 +1,21 @@
+/**
+ * GitHub API integration for comments, outputs, and job summary
+ * @module action/githubIntegration
+ */
+import type { ActionInputs, ActionExecutionResult, ActionCommentResult, ActionOutput } from "../types/actionTypes.js";
+/**
+ * Post result as comment on PR or issue
+ */
+export declare function postResultComment(inputs: ActionInputs, result: ActionExecutionResult): Promise<ActionCommentResult>;
+/**
+ * Write job summary
+ */
+export declare function writeJobSummary(inputs: ActionInputs, result: ActionExecutionResult): Promise<void>;
+/**
+ * Set all action outputs
+ */
+export declare function setActionOutputs(result: ActionExecutionResult, commentResult?: ActionCommentResult): void;
+/**
+ * Get all outputs as typed object (snake_case to match action.yml outputs)
+ */
+export declare function getActionOutputs(result: ActionExecutionResult, commentResult?: ActionCommentResult): ActionOutput;