🤝 Contributing to LookAtni File Markers¶

// 1. Imports - grouped and sorted
import * as vscode from 'vscode';
import * as fs from 'fs';
import * as path from 'path';

import { ConfigManager } from '../utils/configManager';
import { Logger } from '../utils/logger';

// 2. Types and interfaces
interface MarkerOptions {
    includeMetadata: boolean;
    compressionLevel: number;
}

// 3. Constants
const DEFAULT_OPTIONS: MarkerOptions = {
    includeMetadata: true,
    compressionLevel: 1
};

// 4. Main implementation
export class MarkerGenerator {
    // Implementation
}

// Classes: PascalCase
class MarkerGenerator {}

// Functions and variables: camelCase
function generateMarkers() {}
const fileCount = 10;

// Constants: UPPER_SNAKE_CASE
const MAX_FILE_SIZE = 1024 * 1024;

// Interfaces: PascalCase with 'I' prefix (optional)
interface IMarkerConfig {}
// or simply
interface MarkerConfig {}

// Enums: PascalCase
enum FileType {
    Text,
    Binary,
    Archive
}

/**
 * Generates marker files for the specified directory.
 * 
 * @param sourcePath - The path to the source directory
 * @param options - Configuration options for marker generation
 * @returns Promise that resolves to the generated marker file path
 * 
 * @example
 * ```typescript
 * const markerPath = await generateMarkers('/path/to/project', {
 *     includeMetadata: true,
 *     compressionLevel: 2
 * });
 * ```
 */
async function generateMarkers(
    sourcePath: string, 
    options: MarkerOptions
): Promise<string> {
    // Implementation
}

// Use specific error types
class MarkerGenerationError extends Error {
    constructor(
        message: string,
        public readonly sourcePath: string,
        public readonly originalError?: Error
    ) {
        super(message);
        this.name = 'MarkerGenerationError';
    }
}

// Handle errors gracefully
try {
    const result = await generateMarkers(sourcePath, options);
    return result;
} catch (error) {
    if (error instanceof MarkerGenerationError) {
        Logger.error(`Failed to generate markers: ${error.message}`);
        throw error;
    } else {
        Logger.error(`Unexpected error: ${error}`);
        throw new MarkerGenerationError(
            'Unexpected error during marker generation',
            sourcePath,
            error
        );
    }
}

// Command registration
export function activate(context: vscode.ExtensionContext) {
    const disposable = vscode.commands.registerCommand(
        'lookatni.generateMarkers',
        async (uri?: vscode.Uri) => {
            try {
                await generateMarkersCommand(uri);
            } catch (error) {
                vscode.window.showErrorMessage(
                    `Failed to generate markers: ${error.message}`
                );
            }
        }
    );

    context.subscriptions.push(disposable);
}

// Command implementation
async function generateMarkersCommand(uri?: vscode.Uri): Promise<void> {
    const sourcePath = uri?.fsPath || vscode.workspace.rootPath;

    if (!sourcePath) {
        throw new Error('No workspace folder selected');
    }

    // Show progress
    await vscode.window.withProgress({
        location: vscode.ProgressLocation.Notification,
        title: 'Generating markers...',
        cancellable: true
    }, async (progress, token) => {
        // Implementation with progress updates
        progress.report({ increment: 0, message: 'Scanning files...' });

        // Check for cancellation
        if (token.isCancellationRequested) {
            return;
        }

        // Continue implementation...
    });
}

// Type-safe configuration access
interface ExtensionConfig {
    includeMetadata: boolean;
    compressionLevel: number;
    excludePatterns: string[];
}

function getConfiguration(): ExtensionConfig {
    const config = vscode.workspace.getConfiguration('lookatni');

    return {
        includeMetadata: config.get<boolean>('includeMetadata', true),
        compressionLevel: config.get<number>('compressionLevel', 1),
        excludePatterns: config.get<string[]>('excludePatterns', [])
    };
}

// test/unit/markerGenerator.test.ts
import * as assert from 'assert';
import { MarkerGenerator } from '../../src/utils/markerGenerator';

describe('MarkerGenerator', () => {
    let generator: MarkerGenerator;

    beforeEach(() => {
        generator = new MarkerGenerator();
    });

    it('should generate markers for simple project', async () => {
        const result = await generator.generate('/test/project');

        assert.ok(result);
        assert.ok(result.includes('// === File:'));
    });

    it('should handle binary files correctly', async () => {
        // Test implementation
    });
});

// test/integration/extension.test.ts
import * as vscode from 'vscode';
import * as assert from 'assert';

describe('Extension Integration Tests', () => {
    it('should activate extension successfully', async () => {
        const extension = vscode.extensions.getExtension('rafa-mori.lookatni-file-markers');

        assert.ok(extension);
        await extension.activate();
        assert.ok(extension.isActive);
    });

    it('should register all commands', async () => {
        const commands = await vscode.commands.getCommands();

        assert.ok(commands.includes('lookatni.generateMarkers'));
        assert.ok(commands.includes('lookatni.extractFiles'));
        // ... test other commands
    });
});