How To Submit A Bug Report For Continue

Hey everyone! So, you've stumbled upon a bug while using Continue, huh? Bummer! But don't you worry, guys, we've all been there. The good news is that helping us squash these bugs is super straightforward. This guide is all about making sure your bug reports are top-notch, so we can get things fixed lickety-split. Following these steps ensures we get all the juicy details needed to reproduce and resolve the issue efficiently. Think of it as your superhero guide to helping us make Continue even better for everyone.

Before You Hit That Submit Button: The Essential Checks

Alright, before you dive headfirst into writing up your bug report, there are a few crucial steps to take. These aren't just busywork; they're designed to save you and the development team a ton of time and effort. First off, have you tried using the "Ask AI" feature right there on the Continue docs site? Seriously, this AI is pretty smart and has a vast knowledge base. It might just have the answer you're looking for, or at least point you in the right direction. It's amazing how often a quick question to the AI can solve a problem without needing a full report. Plus, you get to play around with the AI more, which is always fun, right?

Next up, let's talk about community intel. It's a good idea to take a peek at the GitHub discussions. See if anyone else has already chatted about the same snag you're experiencing. You might find a workaround, a solution, or even just confirmation that it's a known issue being looked into. It’s like checking the forums before posting a question in a game – someone else might have already paved the way. If you find a similar discussion, chime in there! It helps consolidate information and keeps things tidy.

Following that, let's check the open issues on GitHub. This is where active bugs are tracked. Maybe your bug is already listed! If it is, great! You can add your experience to the existing report – sometimes more details from different users are exactly what the devs need to pinpoint the problem. If it’s not there, then it’s definitely time to create a new report. This step is super important to avoid duplicate reports, which can clutter the issue tracker and slow down the process for everyone involved. We want to make sure every unique problem gets the attention it deserves.

Finally, have you consulted the troubleshooting guide on the Continue Docs? This is our go-to resource for common problems and their solutions. It's packed with helpful tips and tricks that might just save the day. Think of it as the first aid kit for Continue users. If you've gone through all these steps and still haven't found a resolution, then congratulations, you're ready to file an awesome bug report!

Your Environment: Painting the Full Picture

Now, to help us help you, we need to know the nitty-gritty details about your setup. This section is where you become a detective, gathering all the relevant environment info. We need to know what Operating System (OS) you're running on – Windows, macOS, Linux? Be specific! The version matters too.

Next, tell us the Continue version you're using. You can usually find this within the Continue extension settings in your IDE. Knowing the exact version helps us identify if the bug is specific to a particular release. We also need the IDE version. Are you on the latest VS Code? Or maybe you're using a different IDE altogether? The IDE itself can sometimes play a role in how extensions behave, so this info is gold.

What Model are you using with Continue? Are you connected to OpenAI's GPT-4, a local Ollama model, or something else entirely? The model and its configuration can significantly impact how Continue interacts and behaves. If you're using a custom config, paste that config here. Make sure to carefully format it, perhaps using a code block, so it's readable. If you've configured agents, providing the specific agent configuration or a link to it in the Continue Hub is incredibly helpful. This detailed environmental information is like giving us the blueprints to your setup. Without it, we're kind of flying blind, trying to guess what might be going on. The more precise you are here, the faster we can narrow down the potential causes of the bug. Remember, precision is key! Don't just say "Windows"; say "Windows 11 Pro 23H2". Don't just say "VS Code"; say "Visual Studio Code 1.85.1". This level of detail is absolutely crucial for effective debugging.

The Description: What's Going On?

This is where you tell us the story of the bug. Be clear, concise, and specific. Start with a brief, descriptive title for the bug itself – something that summarizes the issue at a glance. For example, instead of "It's broken," try "Autocompletion suggestions disappear after typing two characters." This title should immediately give context.

Then, in the main body of the description, elaborate on the problem. What exactly is happening that shouldn't be? What are you expecting to happen instead? Use bold text for emphasis on key actions or symptoms. For instance, "When I trigger autocompletion by typing Ctrl+Space, I expect to see a list of relevant code suggestions. However, the suggestions disappear immediately after the first character is typed, and only reappear if I delete the character and retype it."

Try to avoid vague language. Instead of saying "it's slow," quantify it if possible: "The response time for the /generate command increased from ~5 seconds to over 30 seconds after the latest update." If you encounter any error messages, quote them precisely or include screenshots if appropriate. Mention any specific files or code snippets that seem to trigger the bug, but be mindful of sensitive information – anonymize or generalize if necessary. Think about the core functionality that is affected. Is it code generation, autocompletion, context retrieval, or something else? Clearly stating the impact helps us prioritize. Good descriptions are the bedrock of effective bug reporting, so take your time here. Imagine you're explaining the problem to a friend who knows nothing about Continue; you need to give them enough information to understand the situation fully. Your clarity directly translates to our speed in fixing it!

To Reproduce: The Step-by-Step Recipe

This is arguably the most important part of your bug report, guys. If we can't reliably reproduce the bug on our end, it's incredibly difficult to fix it. So, think of this section as a recipe. We need clear, numbered steps that anyone can follow to make the bug happen. Be exhaustive!

Start from a clean state if possible. For example: "1. Open a new, empty Python file in VS Code." or "1. Launch Continue with a fresh configuration (no custom agents loaded)."

Detail every single action you take. If you click a button, say which one. If you type something, show what you typed. If you use a keyboard shortcut, specify it. For instance:

1. Open a new Python file named test.py.
2. Type the following code: def my_function(arg1, arg).
3. Press Ctrl+Space to trigger autocompletion.
4. Observe that the suggestion list disappears immediately.
5. Delete the last character (().
6. Retype the last character (().
7. Observe that the suggestion list now appears and functions normally.

Be as precise as humanly possible. If the bug only happens under specific conditions, mention them. Does it happen only with certain file types? Only after a long period of usage? Only when a specific model is selected? Include any relevant context that might be unique to your situation, but remember to keep the steps focused on reproducing the bug. If you mention using a specific model or configuration, ensure that information is also present in the "Relevant environment info" section. The goal here is to provide a foolproof method for our developers to encounter the exact same problem you are facing. If a step is optional or might influence the outcome, state that clearly. Think of this as a script that, when run, reliably demonstrates the defect. A well-documented reproduction path is like a golden ticket for bug fixing!

Log Output: The Digital Footprints

Finally, the log output! This is where Continue and your IDE leave digital footprints that can reveal what went wrong. When you encounter the bug, immediately try to grab the relevant log output. This often involves opening the IDE's developer console or the specific log view for the Continue extension.

In VS Code, for example, you can usually access logs via Help > Toggle Developer Tools and then navigating to the "Console" tab. Look for any error messages, warnings, or unusual entries that appear around the time you experienced the bug. Copy the entire relevant section, not just a single line, as context is often critical. If there are multiple error messages, include them all.

Make sure to filter out any sensitive information before pasting the logs. This could include API keys, personal data, or proprietary code snippets. You can replace these with placeholders like [API_KEY_REDACTED] or [CODE_SNIPPET_REDACTED]. Formatting the logs correctly using a code block (triple backticks ```) is essential for readability. Poorly formatted logs can be incredibly hard to parse.

If the bug is related to a specific action, try to clear the logs (if possible) and then perform only the steps to reproduce the bug, followed immediately by copying the newly generated log output. This ensures the logs are focused on the issue at hand and not cluttered with previous activity. The log output can provide crucial clues about internal errors, failed operations, or communication issues that aren't visible to the user. It's the technical evidence that backs up your bug report. Don't skip this step, guys – it's a lifesaver for debugging!