n8n-nodes-github-copilot 3.1.0 → 3.2.0

package/dist/nodes/GitHubCopilotChatAPI/utils/audioProcessor.d.ts

@@ -0,0 +1,11 @@
+import { IExecuteFunctions } from 'n8n-workflow';
+import { ProcessedFileResult } from './types';
+export declare function processAudioFile(context: IExecuteFunctions, itemIndex: number, audioSource: string, audioFile?: string, audioUrl?: string, audioProperty?: string): Promise<ProcessedFileResult>;
+export declare function chunkAudioData(base64Data: string, maxChunkSize?: number): string[];
+export declare function optimizeAudioForTokens(base64Data: string, maxTokens?: number): {
+    data: string;
+    truncated: boolean;
+    originalTokens: number;
+    finalTokens: number;
+};
+export declare function createAudioSummary(filename: string, size: number, duration?: number): string;

package/dist/nodes/GitHubCopilotChatAPI/utils/audioProcessor.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAudioSummary = exports.optimizeAudioForTokens = exports.chunkAudioData = exports.processAudioFile = void 0;
+const helpers_1 = require("./helpers");
+async function processAudioFile(context, itemIndex, audioSource, audioFile, audioUrl, audioProperty) {
+    var _a, _b;
+    let audioBuffer;
+    let filename;
+    switch (audioSource) {
+        case 'file':
+            if (!audioFile) {
+                throw new Error('Audio file content is required when source is "file"');
+            }
+            audioBuffer = Buffer.from(audioFile, 'base64');
+            filename = 'uploaded_audio.mp3';
+            break;
+        case 'url':
+            if (!audioUrl) {
+                throw new Error('Audio URL is required when source is "url"');
+            }
+            audioBuffer = await (0, helpers_1.downloadFileFromUrl)(audioUrl);
+            filename = audioUrl.split('/').pop() || 'downloaded_audio.mp3';
+            break;
+        case 'binary':
+            if (!audioProperty) {
+                throw new Error('Audio property name is required when source is "binary"');
+            }
+            audioBuffer = await (0, helpers_1.getFileFromBinary)(context, itemIndex, audioProperty);
+            const items = context.getInputData();
+            const item = items[itemIndex];
+            filename = ((_b = (_a = item.binary) === null || _a === void 0 ? void 0 : _a[audioProperty]) === null || _b === void 0 ? void 0 : _b.fileName) || 'binary_audio.mp3';
+            break;
+        default:
+            throw new Error(`Invalid audio source: ${audioSource}`);
+    }
+    (0, helpers_1.validateFileSize)(audioBuffer, 25600);
+    const base64Audio = audioBuffer.toString('base64');
+    const estimatedTokens = (0, helpers_1.estimateTokens)(base64Audio);
+    if (estimatedTokens > 100000) {
+        throw new Error(`Audio file too large (${estimatedTokens} estimated tokens). Consider using a smaller file.`);
+    }
+    const mimeType = (0, helpers_1.getAudioMimeType)(filename);
+    return {
+        data: base64Audio,
+        mimeType,
+        filename,
+        size: audioBuffer.length,
+        estimatedTokens
+    };
+}
+exports.processAudioFile = processAudioFile;
+function chunkAudioData(base64Data, maxChunkSize = 50000) {
+    const chunks = [];
+    for (let i = 0; i < base64Data.length; i += maxChunkSize) {
+        chunks.push(base64Data.slice(i, i + maxChunkSize));
+    }
+    return chunks;
+}
+exports.chunkAudioData = chunkAudioData;
+function optimizeAudioForTokens(base64Data, maxTokens = 100000) {
+    const originalTokens = (0, helpers_1.estimateTokens)(base64Data);
+    if (originalTokens <= maxTokens) {
+        return {
+            data: base64Data,
+            truncated: false,
+            originalTokens,
+            finalTokens: originalTokens
+        };
+    }
+    const compressionRatio = maxTokens / originalTokens;
+    const targetLength = Math.floor(base64Data.length * compressionRatio);
+    const compressedData = base64Data.slice(0, Math.max(targetLength, 1000));
+    return {
+        data: compressedData,
+        truncated: true,
+        originalTokens,
+        finalTokens: (0, helpers_1.estimateTokens)(compressedData)
+    };
+}
+exports.optimizeAudioForTokens = optimizeAudioForTokens;
+function createAudioSummary(filename, size, duration) {
+    const sizeKB = Math.round(size / 1024);
+    const durationText = duration ? ` (${Math.round(duration)}s)` : '';
+    return `Audio file: ${filename} - ${sizeKB}KB${durationText}. File too large for direct processing, providing description instead.`;
+}
+exports.createAudioSummary = createAudioSummary;

package/dist/nodes/GitHubCopilotChatAPI/utils/helpers.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { IExecuteFunctions } from 'n8n-workflow';
+import { CopilotResponse } from './types';
+export declare function makeApiRequest(context: IExecuteFunctions, endpoint: string, body: Record<string, unknown>): Promise<CopilotResponse>;
+export declare function downloadFileFromUrl(url: string): Promise<Buffer>;
+export declare function getFileFromBinary(context: IExecuteFunctions, itemIndex: number, propertyName: string): Promise<Buffer>;
+export declare function getImageMimeType(filename: string): string;
+export declare function getAudioMimeType(filename: string): string;
+export declare function validateFileSize(buffer: Buffer, maxSizeKB?: number): void;
+export declare function estimateTokens(base64String: string): number;
+export declare function validateTokenLimit(estimatedTokens: number, maxTokens?: number): {
+    valid: boolean;
+    message?: string;
+};
+export declare function truncateToTokenLimit(content: string, maxTokens?: number): {
+    content: string;
+    truncated: boolean;
+    originalTokens: number;
+    finalTokens: number;
+};

package/dist/nodes/GitHubCopilotChatAPI/utils/helpers.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.truncateToTokenLimit = exports.validateTokenLimit = exports.estimateTokens = exports.validateFileSize = exports.getAudioMimeType = exports.getImageMimeType = exports.getFileFromBinary = exports.downloadFileFromUrl = exports.makeApiRequest = void 0;
+async function makeApiRequest(context, endpoint, body) {
+    const credentials = await context.getCredentials('githubApi');
+    const options = {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${credentials.accessToken}`,
+            'Content-Type': 'application/json',
+            'User-Agent': 'n8n-github-copilot-chat-api-node',
+        },
+        body: JSON.stringify(body),
+    };
+    const response = await fetch(`https://api.githubcopilot.com${endpoint}`, options);
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`GitHub Copilot API error: ${response.status} ${response.statusText}. ${errorText}`);
+    }
+    return await response.json();
+}
+exports.makeApiRequest = makeApiRequest;
+async function downloadFileFromUrl(url) {
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to download file from URL: ${response.status} ${response.statusText}`);
+    }
+    return Buffer.from(await response.arrayBuffer());
+}
+exports.downloadFileFromUrl = downloadFileFromUrl;
+async function getFileFromBinary(context, itemIndex, propertyName) {
+    const items = context.getInputData();
+    const item = items[itemIndex];
+    if (!item.binary || !item.binary[propertyName]) {
+        throw new Error(`No binary data found in property "${propertyName}"`);
+    }
+    const binaryData = item.binary[propertyName];
+    if (binaryData.data) {
+        return Buffer.from(binaryData.data, 'base64');
+    }
+    else if (binaryData.id) {
+        return await context.helpers.getBinaryDataBuffer(itemIndex, propertyName);
+    }
+    else {
+        throw new Error(`Invalid binary data format in property "${propertyName}"`);
+    }
+}
+exports.getFileFromBinary = getFileFromBinary;
+function getImageMimeType(filename) {
+    const ext = filename.toLowerCase().split('.').pop();
+    switch (ext) {
+        case 'jpg':
+        case 'jpeg':
+            return 'image/jpeg';
+        case 'png':
+            return 'image/png';
+        case 'webp':
+            return 'image/webp';
+        case 'gif':
+            return 'image/gif';
+        default:
+            return 'image/jpeg';
+    }
+}
+exports.getImageMimeType = getImageMimeType;
+function getAudioMimeType(filename) {
+    const ext = filename.toLowerCase().split('.').pop();
+    switch (ext) {
+        case 'mp3':
+            return 'audio/mpeg';
+        case 'wav':
+            return 'audio/wav';
+        case 'm4a':
+            return 'audio/mp4';
+        case 'flac':
+            return 'audio/flac';
+        case 'ogg':
+            return 'audio/ogg';
+        case 'aac':
+            return 'audio/aac';
+        default:
+            return 'audio/mpeg';
+    }
+}
+exports.getAudioMimeType = getAudioMimeType;
+function validateFileSize(buffer, maxSizeKB = 1024) {
+    const sizeKB = buffer.length / 1024;
+    if (sizeKB > maxSizeKB) {
+        throw new Error(`File size ${sizeKB.toFixed(2)}KB exceeds limit of ${maxSizeKB}KB`);
+    }
+}
+exports.validateFileSize = validateFileSize;
+function estimateTokens(base64String) {
+    return Math.ceil((base64String.length / 4 * 3) / 4);
+}
+exports.estimateTokens = estimateTokens;
+function validateTokenLimit(estimatedTokens, maxTokens = 128000) {
+    if (estimatedTokens <= maxTokens) {
+        return { valid: true };
+    }
+    return {
+        valid: false,
+        message: `Content too large: ${estimatedTokens} tokens exceeds limit of ${maxTokens}. Consider using smaller files or text.`
+    };
+}
+exports.validateTokenLimit = validateTokenLimit;
+function truncateToTokenLimit(content, maxTokens = 100000) {
+    const originalTokens = Math.ceil(content.length / 4);
+    if (originalTokens <= maxTokens) {
+        return {
+            content,
+            truncated: false,
+            originalTokens,
+            finalTokens: originalTokens
+        };
+    }
+    const targetLength = Math.floor(content.length * (maxTokens / originalTokens));
+    const truncatedContent = content.slice(0, targetLength) + '...[truncated]';
+    return {
+        content: truncatedContent,
+        truncated: true,
+        originalTokens,
+        finalTokens: Math.ceil(truncatedContent.length / 4)
+    };
+}
+exports.truncateToTokenLimit = truncateToTokenLimit;

package/dist/nodes/GitHubCopilotChatAPI/utils/imageProcessor.d.ts

@@ -0,0 +1,8 @@
+import { IExecuteFunctions } from 'n8n-workflow';
+import { ProcessedFileResult, OptimizationOptions } from './types';
+export declare function processImageFile(context: IExecuteFunctions, itemIndex: number, imageSource: string, imageFile?: string, imageUrl?: string, imageProperty?: string, optimization?: OptimizationOptions): Promise<ProcessedFileResult>;
+export declare function compressImageToTokenLimit(base64Data: string, maxTokens?: number): string;
+export declare function resizeImageDimensions(originalWidth: number, originalHeight: number, maxWidth?: number, maxHeight?: number): {
+    width: number;
+    height: number;
+};

package/dist/nodes/GitHubCopilotChatAPI/utils/imageProcessor.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resizeImageDimensions = exports.compressImageToTokenLimit = exports.processImageFile = void 0;
+const helpers_1 = require("./helpers");
+async function processImageFile(context, itemIndex, imageSource, imageFile, imageUrl, imageProperty, optimization) {
+    var _a, _b;
+    let imageBuffer;
+    let filename;
+    switch (imageSource) {
+        case 'file':
+            if (!imageFile) {
+                throw new Error('Image file content is required when source is "file"');
+            }
+            imageBuffer = Buffer.from(imageFile, 'base64');
+            filename = 'uploaded_image.jpg';
+            break;
+        case 'url':
+            if (!imageUrl) {
+                throw new Error('Image URL is required when source is "url"');
+            }
+            imageBuffer = await (0, helpers_1.downloadFileFromUrl)(imageUrl);
+            filename = imageUrl.split('/').pop() || 'downloaded_image.jpg';
+            break;
+        case 'binary':
+            if (!imageProperty) {
+                throw new Error('Image property name is required when source is "binary"');
+            }
+            imageBuffer = await (0, helpers_1.getFileFromBinary)(context, itemIndex, imageProperty);
+            const items = context.getInputData();
+            const item = items[itemIndex];
+            filename = ((_b = (_a = item.binary) === null || _a === void 0 ? void 0 : _a[imageProperty]) === null || _b === void 0 ? void 0 : _b.fileName) || 'binary_image.jpg';
+            break;
+        default:
+            throw new Error(`Invalid image source: ${imageSource}`);
+    }
+    if (optimization) {
+        imageBuffer = await optimizeImage(imageBuffer, optimization);
+    }
+    (0, helpers_1.validateFileSize)(imageBuffer, 20480);
+    const base64Image = imageBuffer.toString('base64');
+    const estimatedTokens = (0, helpers_1.estimateTokens)(base64Image);
+    if (estimatedTokens > 50000) {
+        const compressedBuffer = await optimizeImage(imageBuffer, {
+            quality: 70,
+            maxSizeKB: (optimization === null || optimization === void 0 ? void 0 : optimization.maxSizeKB) || 1024
+        });
+        const compressedBase64 = compressedBuffer.toString('base64');
+        const compressedTokens = (0, helpers_1.estimateTokens)(compressedBase64);
+        if (compressedTokens < estimatedTokens) {
+            return {
+                data: compressedBase64,
+                mimeType: (0, helpers_1.getImageMimeType)(filename),
+                filename,
+                size: compressedBuffer.length,
+                estimatedTokens: compressedTokens
+            };
+        }
+    }
+    const mimeType = (0, helpers_1.getImageMimeType)(filename);
+    return {
+        data: base64Image,
+        mimeType,
+        filename,
+        size: imageBuffer.length,
+        estimatedTokens
+    };
+}
+exports.processImageFile = processImageFile;
+async function optimizeImage(buffer, options) {
+    if (options.maxSizeKB && buffer.length / 1024 > options.maxSizeKB) {
+        const compressionRatio = Math.min(0.8, options.maxSizeKB / (buffer.length / 1024));
+        const targetSize = Math.floor(buffer.length * compressionRatio);
+        if (targetSize < buffer.length) {
+            return buffer.slice(0, Math.max(targetSize, 1024));
+        }
+    }
+    return buffer;
+}
+function compressImageToTokenLimit(base64Data, maxTokens = 50000) {
+    const estimatedTokens = (0, helpers_1.estimateTokens)(base64Data);
+    if (estimatedTokens <= maxTokens) {
+        return base64Data;
+    }
+    const compressionRatio = maxTokens / estimatedTokens;
+    const targetLength = Math.floor(base64Data.length * compressionRatio);
+    return base64Data.slice(0, Math.max(targetLength, 1000));
+}
+exports.compressImageToTokenLimit = compressImageToTokenLimit;
+function resizeImageDimensions(originalWidth, originalHeight, maxWidth = 1024, maxHeight = 1024) {
+    let { width, height } = { width: originalWidth, height: originalHeight };
+    if (width > maxWidth) {
+        height = (height * maxWidth) / width;
+        width = maxWidth;
+    }
+    if (height > maxHeight) {
+        width = (width * maxHeight) / height;
+        height = maxHeight;
+    }
+    return { width: Math.round(width), height: Math.round(height) };
+}
+exports.resizeImageDimensions = resizeImageDimensions;

package/dist/nodes/GitHubCopilotChatAPI/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types';
+export * from './helpers';
+export * from './audioProcessor';
+export * from './imageProcessor';

package/dist/nodes/GitHubCopilotChatAPI/utils/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./helpers"), exports);
+__exportStar(require("./audioProcessor"), exports);
+__exportStar(require("./imageProcessor"), exports);

package/dist/nodes/GitHubCopilotChatAPI/utils/types.d.ts

@@ -0,0 +1,45 @@
+import { IExecuteFunctions } from 'n8n-workflow';
+export interface ChatMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string | Array<{
+        type: string;
+        text?: string;
+        image_url?: {
+            url: string;
+        };
+    }>;
+}
+export interface CopilotResponse {
+    choices: Array<{
+        message: {
+            content: string;
+        };
+        finish_reason: string;
+    }>;
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+}
+export interface FileProcessOptions {
+    context: IExecuteFunctions;
+    itemIndex: number;
+    source: 'manual' | 'url' | 'binary';
+    filePath?: string;
+    url?: string;
+    binaryProperty?: string;
+}
+export interface ProcessedFileResult {
+    data: string;
+    mimeType: string;
+    filename: string;
+    size: number;
+    estimatedTokens: number;
+}
+export interface OptimizationOptions {
+    maxWidth?: number;
+    maxHeight?: number;
+    quality?: number;
+    maxSizeKB?: number;
+}

package/dist/nodes/GitHubCopilotChatAPI/utils/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-github-copilot",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "description": "n8n community node for GitHub Copilot with CLI integration and official Chat API access to GPT-5, Claude, Gemini and more using your existing Copilot credits",
   "license": "MIT",
   "homepage": "https://github.com/sufficit/n8n-nodes-github-copilot",