Extension Entry Point (extension.ts)

The file extension.ts serves as the primary entry point for the PixelPilot Visual Studio Code extension. This file closely adheres to best practices recommended for VS Code extension development, ensuring the extension remains responsive and integrates seamlessly within the VS Code ecosystem.

Initialisation

Upon activation of the PixelPilot extension, extension.ts sets up several critical functionalities:

• Chat Participant Creation: A custom chat participant named pixelpilot is created using VS Code's Chat API.
• Output Channel: An output channel (PixelPilot) is established to log important information, errors, and debugging messages, providing visibility into the extension's operation for both users and developers.

Mastery Level and Model Configuration

The extension initialises global state settings for mastery levels and AI model selections:

• Mastery Levels: Three mastery levels (NOVICE, INTERMEDIATE, PRO) are predefined with clear descriptions, allowing PixelPilot to tailor responses based on the user's expertise. The default mastery level is set to NOVICE.
• Model Selection: Default AI models for chat completion and code generation are configured (gpt-4o). Users can customise these settings later through commands provided by the extension.

Periodic Tasks

• Image State Management: The extension executes updateImageState() every 60 seconds to manage and refresh the state of generated images or assets, ensuring the visual content remains current for the user's game development workflow.

Commands and Interactivity

Several commands are registered to enhance user interactivity and customisation:

• PixelPilot Walkthrough (pixelpilot.start): This command initiates an interactive walkthrough via a VS Code Webview Panel, guiding users through the extension’s features step-by-step. The walkthrough serves as a game template generator, assisting users in refining their ideas into a clear, actionable prompt for code generation. It interactively queries the user to determine key parameters, including:
• Game Type
• Target Platform
• Target Controller
• Target Framework
• Game Description
• Model Selection Commands:
• pixelpilot.selectChatCompletionModel: Allows users to select their preferred AI model for chat completion tasks from our list of supported models (gpt-4o, Phi-4, Llama-3.3-70B-Instruct, DeepSeek-V3, DeepSeek-R1).
• pixelpilot.selectCodeGenerationModel: Allows users to select their preferred AI model for code generation tasks (gpt-4o, Phi-4, Llama-3.3-70B-Instruct, DeepSeek-V3, DeepSeek-R1, Codestral-2501, Qwen-2.5-Coder).
• Mastery Level Selection (pixelpilot.selectMasteryLevel): Allows users to select their preferred mastery level, allowing PixelPilot to tailor responses based on the user's expertise.

Lifecycle Management

• Activation: Upon activation, the extension performs all initialisation tasks described above, ensuring smooth integration within VS Code's workflow.
• Deactivation: Currently, the deactivate function is minimal, as explicit resource cleanup is not necessary, but it can be expanded in future updates as required.

This structured approach ensures clarity, maintainability, and ease of future development, aligning with standard VS Code extension development practices and fulfilling the project's MoSCoW requirements.

import * as vscode from 'vscode';
import * as path from 'path';
import { updateImageState } from './util/imageGen';


import { Extension } from './util/Extension';


import { Walkthrough } from './views/walkthrough';


export const CHAT_COMPLETION_MODELS = ['gpt-4o', 'Phi-4', 'Llama-3.3-70B-Instruct', 'DeepSeek-V3', 'DeepSeek-R1'];
export const CODE_GENERATION_MODELS = ['gpt-4o', 'Phi-4', 'Llama-3.3-70B-Instruct', 'DeepSeek-V3', 'DeepSeek-R1', 'Codestral-2501', 'Qwen-2.5-Coder'];


// Extension init.
import handler from './handler';


const PARTICIPANT = vscode.chat.createChatParticipant('pixelpilot', handler);


export const outputChannel = vscode.window.createOutputChannel('PixelPilot');
outputChannel.appendLine('PixelPilot output channel created.');


export function activate(context: vscode.ExtensionContext) {
    outputChannel.show();
    
    updateImageState().catch(console.error);


        // Set up a periodic check to update the image state
    setInterval(() => {
        updateImageState().catch(console.error);
    }, 60000); // Check every 60 seconds


    // Set the default mastery levels.
    context.globalState.update('masteryLevel', 'NOVICE'); // Default mastery level.
    context.globalState.update('NOVICE', "A novice is someone who is just starting to learn game development. They are new to programming and game design concepts. They might have little to no experience with coding and are learning the basics of how to create simple games. At this level, they are learning how to use game development tools, understand basic programming concepts like variables and loops, and create simple game mechanics. Specific skills: - Understanding basic programming concepts (variables, loops, conditionals) - Using a game development environment (e.g., Scratch, MakeCode, PyGame) - Creating simple 2D games with basic mechanics (e.g., moving a character, collecting items) - Learning how to debug simple errors");
    context.globalState.update('INTERMEDIATE', "An intermediate learner has a good grasp of basic programming and game design concepts. They can create more complex games and understand how to use more advanced features of game development tools. They are comfortable with coding and can implement more sophisticated game mechanics. At this level, they are learning about game physics, animations, and user interfaces. Specific Skills: - Writing more complex code (functions, arrays, objects) - Using intermediate features of game development tools (e.g., Unity, Godot) - Creating 2D games with more advanced mechanics (e.g., physics-based interactions, animations) - Designing user interfaces and menus - Debugging and optimising game performance");
    context.globalState.update('PRO', "A pro learner is highly skilled in game development and has a deep understanding of programming and game design. They can create complex and polished games, using advanced features of game development tools. They are capable of working on larger projects and collaborating with others. At this level, they are learning about advanced game design principles, 3D game development, and integrating external libraries and assets. Specific skills: - Writing advanced code (inheritance, polymorphism, design patterns) - Using advanced features of game development tools (e.g., Unreal Engine, advanced Unity features) - Creating 3D games with complex mechanics and high-quality graphics - Implementing multiplayer functionality and networked games - Collaborating with others on game projects (version control, project management) - Integrating external libraries and assets (e.g., physics engines, AI libraries)");


    // Set the default models.
    context.globalState.update('chatCompletionModel', 'gpt-4o');
    context.globalState.update('codeGenerationModel', 'gpt-4o');


    // Update context.
    Extension.context = context;


    const startCommand = vscode.commands.registerCommand('pixelpilot.start', async () => {


    const panel = vscode.window.createWebviewPanel(
        'walkthrough',
        'PixelPilot Walkthrough',
        vscode.ViewColumn.One,
        { enableScripts: true }
    );


    const walkthrough = new Walkthrough(panel);
    walkthrough.startWalkthrough();
    });


    const selectChatCompletionModelCommand = vscode.commands.registerCommand('pixelpilot.selectChatCompletionModel', async () => {
    const selectedModel = await vscode.window.showQuickPick(CHAT_COMPLETION_MODELS, {
        placeHolder: 'Select a Chat Completion model',
    });


    if (selectedModel) {
        context.globalState.update('chatCompletionModel', selectedModel);
        vscode.window.showInformationMessage(`Selected Chat Completion model: ${selectedModel}`);


        // Update context in the custom Extension class.
        Extension.context = context;
    }
    });


    const selectCodeGenerationModelCommand = vscode.commands.registerCommand('pixelpilot.selectCodeGenerationModel', async () => {
    const selectedModel = await vscode.window.showQuickPick(CODE_GENERATION_MODELS, {
        placeHolder: 'Select a Code Generation model',
    });


    if (selectedModel) {
        context.globalState.update('codeGenerationModel', selectedModel);
        vscode.window.showInformationMessage(`Selected Code Generation model: ${selectedModel}`);


        // Update context in the custom Extension class.
        Extension.context = context;
    }
    });


    const selectMasteryLevel = vscode.commands.registerCommand('pixelpilot.selectMasteryLevel', async () => {
    const selectedMasteryLevel = await vscode.window.showQuickPick(["NOVICE", "INTERMEDIATE", "PRO"], {
        placeHolder: 'Select your mastery level in order for PixelPilot to better tailor its responses to your needs.',
    });


    if (selectedMasteryLevel) {
        context.globalState.update('masteryLevel', selectedMasteryLevel);
        vscode.window.showInformationMessage(`Selected Mastery Level: ${selectedMasteryLevel}`);


        // Update context in the custom Extension class.
        Extension.context = context;
    }
    });


    context.subscriptions.push(startCommand, selectChatCompletionModelCommand, selectCodeGenerationModelCommand, selectMasteryLevel);
}


export function deactivate() {}
             
                

Chat Request Workflow

The chat request workflow within the PixelPilot extension provides a structured and efficient approach to manage user interactions with the AI assistant, ensuring clarity and accuracy in responses. The workflow consists of the following key stages:

Intent Detection

When a user submits a chat request, the system initially classifies the intent behind the user's message. This step determines the type of assistance needed, categorising requests into the following types:

• GENERAL CONVERSATION – for casual greetings, small talk, or non-task-related messages that do not require further clarification.
• GENERAL ASSISTANCE – for quick questions, troubleshooting, or debugging help that does not require code refactoring.
• EXPLAIN CONCEPT – for explaining game development or programming topics.
• IMAGE GENERATION – for drawing, creating assets, or visual elements.
• CODE GENERATION – for writing new scripts or game logic.
• REFACTOR CODE – for improving or debugging existing code.
• FURTHER CLARIFICATION NEEDED – if the user wants to perform a task, but their request is too vague or ambiguous to be categorised as EXPLAIN CONCEPT, IMAGE GENERATION, CODE GENERATION, or REFACTOR CODE.

Context Checking

After the intent has been identified, PixelPilot verifies whether the user has provided sufficient details to proceed with the request. This ensures essential information is present for effective task execution. The system checks for required details based on the request type, as follows:

• GENERAL ASSISTANCE: Does the request include a specific question or issue? If debugging, does the user provide an error message or description of the issue? Does the user provide the expected outcome?
• EXPLAIN CONCEPT: Does the request specify a concept name? Does it mention the user's prior knowledge level? Does it describe what the user wants to learn about the concept?
• IMAGE GENERATION: Does the request specify a theme? Does it describe the key elements of the image? Does it specify an art style? Does the request specify multiple images?
• CODE GENERATION: Does the request specify a programming language? Does it mention a framework or library (if applicable)? Does it describe the desired functionality of the script?
• REFACTOR CODE: Does the request include a code snippet? Does it describe the specific problem the user wants to fix or improve?
• FURTHER CLARIFICATION NEEDED: Does the request indicate that the user wants to perform a task but lacks enough details to be categorised as EXPLAIN CONCEPT, IMAGE GENERATION, CODE GENERATION, or REFACTOR CODE?

Clarifying Questions

If the system identifies that the provided context is insufficient, PixelPilot proactively formulates and presents clarifying questions directly within the chat interface. These questions prompt the user to supply missing or ambiguous details necessary for fulfilling the request.

Task Execution

Upon confirming that sufficient context has been provided, the assistant executes the request using the appropriate AI model, based on the user's previously selected configurations (e.g., GPT-4o, Phi-4, Llama, etc.). Tasks may include generating code snippets, creating visual assets, or providing detailed explanations.

Response Delivery

The result of the task is clearly presented back to the user within the chat interface. The responses are tailored according to the user's selected mastery level - ranging from novice-friendly guidance to advanced technical explanations - ensuring the user receives appropriate, comprehensible, and actionable feedback.

This structured workflow not only streamlines interactions with the AI assistant but also significantly enhances user experience by providing precise, contextually accurate, and tailored assistance for each chat request.