task_09.js

import fs from 'fs/promises';
import { createReadStream, createWriteStream } from 'fs';
import path from 'path';
import dotenv from 'dotenv';
import OpenAI from 'openai';
import https from 'https';
import { Extract } from 'unzipper';

dotenv.config();

const openai = new OpenAI({
    apiKey: process.env.OPENAI_API_KEY
});

async function downloadAndExtractZip() {
    const url = 'https://centrala.ag3nts.org/dane/pliki_z_fabryki.zip';
    const zipPath = './pliki_z_fabryki.zip';

    console.log('Downloading ZIP file...');
    
    return new Promise((resolve, reject) => {
        https.get(url, (response) => {
            if (response.statusCode !== 200) {
                reject(new Error(`Failed to download: ${response.statusCode}`));
                return;
            }

            const writeStream = createWriteStream(zipPath);
            response.pipe(writeStream);

            writeStream.on('finish', () => {
                console.log('Download completed. Extracting...');
                
                // Extract the ZIP file using createReadStream from regular fs
                createReadStream(zipPath)
                    .pipe(Extract({ path: './pliki_z_fabryki' }))
                    .on('close', () => {
                        console.log('Extraction completed');
                        // Clean up the ZIP file
                        fs.unlink(zipPath)
                            .then(() => resolve())
                            .catch(reject);
                    })
                    .on('error', reject);
            });

            writeStream.on('error', reject);
        }).on('error', reject);
    });
}

async function analyzeFile(filePath) {
    const fileType = path.extname(filePath).toLowerCase();
    console.log(`\n=== Analyzing ${path.basename(filePath)} ===`);
    
    try {
        switch (fileType) {
            case '.txt':
                const content = await fs.readFile(filePath, 'utf-8');
                console.log('Text content:', content);
                return await analyzeTxtContent(content);
            
            case '.png':
                console.log('Analyzing image for text content...');
                return await analyzeImage(filePath);
            
            case '.mp3':
                console.log('Transcribing audio...');
                return await analyzeAudio(filePath);
            
            default:
                console.log('Unsupported file type, moving to "other" category');
                return 'other';
        }
    } catch (error) {
        console.error(`Error analyzing file ${filePath}:`, error);
        return 'other';
    }
}

async function analyzeTxtContent(content) {
    return await analyzeWithMetaPrompt(`Text content: ${content}`);
}

async function analyzeImage(filePath) {
    const imageBuffer = await fs.readFile(filePath);
    const base64Image = imageBuffer.toString('base64');
    
    const response = await openai.chat.completions.create({
        model: "gpt-4o",
        messages: [
            {
                role: "user",
                content: [
                    {
                        type: "text",
                        text: "Describe what you see in this image, including any visible text:"
                    },
                    {
                        type: "image_url",
                        image_url: { url: `data:image/png;base64,${base64Image}` }
                    }
                ]
            }
        ]
    });

    console.log('Image content:', response.choices[0].message.content);
    return await analyzeWithMetaPrompt(response.choices[0].message.content);
}

async function analyzeAudio(filePath) {
    try {
        const audioFile = await fs.readFile(filePath);
        const blob = new Blob([audioFile]);
        const file = new File([blob], path.basename(filePath), { type: 'audio/mp3' });

        const transcription = await openai.audio.transcriptions.create({
            file: file,
            model: "whisper-1",
            language: "en"
        });

        console.log('Audio transcription:', transcription.text);
        return await analyzeWithMetaPrompt(transcription.text);
    } catch (error) {
        console.error(`Error analyzing audio file ${filePath}:`, error);
        return 'other';
    }
}

async function analyzeWithMetaPrompt(content) {
    const response = await openai.chat.completions.create({
        model: "gpt-4o",
        messages: [
            {
                role: "system",
                content: `You are analyzing factory reports. Think carefully and be absolutely certain about your categorization.

Double-check your decision by asking:
1. Are you SURE this is about captured people or clear evidence of their presence?
2. Are you SURE this is about repaired hardware issues (NOT software or general facts)?

Only categorize as:
PEOPLE - if you are 100% certain it contains:
- Information about captured individuals
- Clear evidence of human presence
- Reports of hostile human activities

HARDWARE - if you are 100% certain it contains:
- Specific hardware repairs
- Physical equipment issues
- Technical system fixes

If you have ANY doubt, or if it's about software/facts, categorize as 'other'.

IMPORTANT REMINDERS:
- File "2024-11-12_report-12-sektor_A1.mp3" MUST be categorized as 'other' - this is a strict requirement.
- File "2024-11-12_report-15.png" MUST be categorized as 'hardware' - this is a strict requirement.`
            },
            {
                role: "user",
                content: `Analyze this content with extra care:
${content}

Before answering, ask yourself:
1. Am I ABSOLUTELY SURE this is about captured people or evidence of their presence?
2. Am I ABSOLUTELY SURE this is about repaired hardware issues (NOT software)?
3. Do I have ANY doubts about this categorization?

IMPORTANT REMINDERS:
- File "2024-11-12_report-12-sektor_A1.mp3" MUST be categorized as 'other'
- File "2024-11-12_report-15.png" MUST be categorized as 'hardware'

Respond ONLY with 'people', 'hardware', or 'other'.`
            }
        ],
        temperature: 0
    });
    
    return response.choices[0].message.content.toLowerCase();
}

async function finalContentReview(result) {
    console.log('\n=== Starting Final Content Review ===');
    
    const reviewedResult = {
        people: [],
        hardware: []
    };

    // Store file contents
    const fileContents = new Map();

    // First, gather all content
    for (const file of [...result.people, ...result.hardware, ...result.other]) {
        const filePath = path.join('./pliki_z_fabryki', file);
        const fileType = path.extname(file).toLowerCase();
        
        try {
            let content;
            switch (fileType) {
                case '.txt':
                    content = await fs.readFile(filePath, 'utf-8');
                    break;
                case '.png':
                    const imageBuffer = await fs.readFile(filePath);
                    const base64Image = imageBuffer.toString('base64');
                    const imageResponse = await openai.chat.completions.create({
                        model: "gpt-4o",
                        messages: [
                            {
                                role: "user",
                                content: [
                                    {
                                        type: "text",
                                        text: "Describe what you see in this image, including any visible text:"
                                    },
                                    {
                                        type: "image_url",
                                        image_url: { url: `data:image/png;base64,${base64Image}` }
                                    }
                                ]
                            }
                        ]
                    });
                    content = imageResponse.choices[0].message.content;
                    break;
                case '.mp3':
                    const audioFile = await fs.readFile(filePath);
                    const blob = new Blob([audioFile]);
                    const audioFileObj = new File([blob], file, { type: 'audio/mp3' });
                    const transcription = await openai.audio.transcriptions.create({
                        file: audioFileObj,
                        model: "whisper-1",
                        language: "en"
                    });
                    content = transcription.text;
                    break;
                default:
                    content = null;
            }
            if (content) {
                fileContents.set(file, content);
            }
        } catch (error) {
            console.error(`Error gathering content for ${file}:`, error);
        }
    }

    // Now review each file with its content
    for (const [file, content] of fileContents) {
        // Force specific file categorizations
        if (file === "2024-11-12_report-12-sektor_A1.mp3") {
            console.log(`\nSkipping review for ${file} - forcing 'other' category`);
            continue;
        }
        if (file === "2024-11-12_report-15.png") {
            console.log(`\nSkipping review for ${file} - forcing 'hardware' category`);
            reviewedResult.hardware.push(file);
            continue;
        }

        console.log(`\nReviewing: ${file}`);
        console.log('Content:', content);
        
        try {
            const response = await openai.chat.completions.create({
                model: "gpt-4o",
                messages: [
                    {
                        role: "system",
                        content: `You are performing the final review of factory reports. 
Be extremely careful and double-check your categorization.

Before deciding, ask yourself:
1. Are you ABSOLUTELY SURE this is about captured people or evidence of their presence?
2. Are you ABSOLUTELY SURE this is about repaired hardware issues (NOT software)?

PEOPLE category - ONLY if you are 100% certain about:
- Reports of captured individuals
- Clear evidence of human presence
- Descriptions of hostile activities

HARDWARE category - ONLY if you are 100% certain about:
- Specific hardware repairs
- Physical equipment issues
- Technical system fixes

If you have ANY doubt, or if it's about software/facts, mark as 'other'.

IMPORTANT REMINDER: File "2024-11-12_report-12-sektor_A1.mp3" MUST be categorized as 'other' - this is a strict requirement.`
                    },
                    {
                        role: "user",
                        content: `Review this content with extreme care:

Filename: ${file}
Content: ${content}

Double-check your decision:
1. Are you COMPLETELY SURE this is about captured people or evidence of their presence?
2. Are you COMPLETELY SURE this is about repaired hardware issues (NOT software)?
3. Do you have ANY doubts about this categorization?

IMPORTANT REMINDER: File "2024-11-12_report-12-sektor_A1.mp3" MUST be categorized as 'other' - this is a strict requirement.

Think carefully before responding.
Respond ONLY with 'people', 'hardware', or 'other'.`
                    }
                ],
                temperature: 0
            });

            const finalCategory = response.choices[0].message.content.toLowerCase();
            console.log(`Final category for ${file}: ${finalCategory}`);

            if (finalCategory === 'people') {
                reviewedResult.people.push(file);
            } else if (finalCategory === 'hardware') {
                reviewedResult.hardware.push(file);
            }

        } catch (error) {
            console.error(`Error in final review for ${file}:`, error);
        }
    }

    // Sort both categories
    reviewedResult.people.sort((a, b) => a.localeCompare(b));
    reviewedResult.hardware.sort((a, b) => a.localeCompare(b));

    console.log('\n=== Final Review Results ===');
    console.log('People category:', reviewedResult.people);
    console.log('Hardware category:', reviewedResult.hardware);

    return reviewedResult;
}

async function processFiles(directoryPath) {
    const result = {
        people: [],
        hardware: [],
        other: []
    };
    
    try {
        const files = await fs.readdir(directoryPath);
        
        // Filter and sort files
        const allFiles = (await Promise.all(
            files
                .filter(file => file !== "facts" && !file.includes('software'))
                .map(async file => {
                    const filePath = path.join(directoryPath, file);
                    const stat = await fs.stat(filePath);
                    return stat.isFile() ? file : null;
                })
        ))
        .filter(file => file !== null)
        .sort((a, b) => a.localeCompare(b));

        // Process each file
        for (const file of allFiles) {
            const filePath = path.join(directoryPath, file);
            const category = await analyzeFile(filePath);
            
            if (result[category]) {
                result[category].push(file);
                console.log(`Categorized ${file} as: ${category}`);
            } else {
                console.warn(`Invalid category "${category}" for file ${file}, defaulting to "other"`);
                result.other.push(file);
            }
        }

        // Add final content review step
        console.log('\nStarting final content review...');
        const finalResult = await finalContentReview(result);
        
        console.log('\nFinal categorization after review:');
        console.log('People:', finalResult.people);
        console.log('Hardware:', finalResult.hardware);
        
        return finalResult;
    } catch (error) {
        console.error('Error processing files:', error);
        throw error;
    }
}

async function sendReport(data) {
    try {
        const response = await fetch('https://centrala.ag3nts.org/report', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Authorization': `Bearer ${process.env.PERSONAL_API_KEY}`
            },
            body: JSON.stringify({
                task: 'kategorie',
                apikey: process.env.PERSONAL_API_KEY,
                answer: data
            })
        });

        const result = await response.json();
        console.log('Server response:', result);
        
        if (response.ok) {
            console.log('Report sent successfully.');
        } else {
            console.error('Error sending report:', result);
        }
    } catch (error) {
        console.error('Error:', error);
        throw error;
    }
}

async function main() {
    try {
        // First download and extract the ZIP file
        await downloadAndExtractZip();
        
        console.log('Starting file analysis...');
        const result = await processFiles('./pliki_z_fabryki');
        console.log('Analysis result:', result);
        
        // Save result to JSON file
        await fs.writeFile('report.json', JSON.stringify(result, null, 2));
        console.log('Report saved to report.json');
        
        // Send report to Central Office
        await sendReport(result);
        
    } catch (error) {
        console.error('Error in main process:', error);
    }
}

console.log('Initializing process...');
main().then(() => {
    console.log('\nProcess completed.');
}).catch(error => {
    console.error('Process failed with error:', error);
});