TermBuddy

Transforms debugging by integrating LLMs into your terminal, instantly diagnosing build failures and runtime bugs. It provides precise fixes, reducing downtime and keeping your workflow smooth.

Comment

Inspiration

Developers spend a significant amount of time diagnosing build failures and runtime errors—often digging through logs, searching Stack Overflow, and testing multiple fixes manually. We wanted to build a tool that reduces debugging time by integrating AI-powered solutions directly into the terminal, keeping developers focused on coding instead of troubleshooting.

What it does

TermBuddy is a command-line AI debugging assistant that:

  • Detects build-time and runtime errors in real-time.
  • Automatically retrieves relevant discussions from Stack Overflow and GitHub Issues.
  • Uses LLMs to suggest precise fixes, formatted as structured patches.
  • Scrapes Java and Spring Boot documentation from TutorialsPoint for API-specific solutions.
  • Rewrites queries dynamically based on the API being searched to get the most accurate results.
  • Seamlessly integrates into the developer workflow, reducing the time spent debugging.

How we built it

  • Error Capturing: Hooks into the terminal to detect build failures and exceptions.
  • Query Generation: Uses NLP to generate optimized search queries from error logs.
  • Retrieval System: Queries Stack Overflow & GitHub Issues using FAISS-based semantic search.
  • Documentation Scraping: Extracts Java & Spring Boot references from TutorialsPoint for API-specific solutions.
  • Dynamic Query Rewriting: Adjusts search queries based on context (API, error type, language-specific debugging best practices).
  • LLM-Generated Fixes: Uses OpenAI’s GPT models to generate structured, actionable fixes.
  • Multi-threaded API Calls: Ensures fast retrieval of relevant discussions.
  • Formatted Output: Fixes are returned in Markdown patches, making them easy to apply.

Challenges we ran into

  1. Query Optimization: Crafting precise search queries from cryptic error messages.
  2. Latency Reduction: Speeding up retrieval from multiple sources while keeping results relevant.
  3. Structured Fixes: Ensuring LLM-generated fixes are clear, applicable, and formatted properly.
  4. Handling Edge Cases: Errors vary across programming languages, requiring adaptive query generation.
  5. Scraping and Parsing Documentation: Ensuring extracted content is accurate and relevant to API issues.

Accomplishments that we're proud of

  • Successfully integrated AI-assisted debugging into the command line.
  • Developed a high-speed retrieval system using Stack Overflow, GitHub Issues, and TutorialsPoint documentation.
  • Optimized query rewriting for different error categories and API searches.
  • Created structured, Markdown-formatted fixes that are developer-friendly.

What we learned

  • Context-aware debugging significantly reduces time spent resolving errors.
  • Combining structured data retrieval (Stack Overflow, GitHub Issues, documentation scraping) with LLMs results in more accurate solutions.
  • Multi-threading API calls drastically improves response times.
  • Developers prefer inline fixes over external documentation—integrating AI within their workflow is key.

What's next for TermBuddy

  • Expanding language support for more programming environments.
  • Adding more documentation sources (e.g., JavaDocs, Microsoft Docs, and Python Docs).
  • Fine-tuning query rewriting for more APIs and frameworks.
  • Caching frequent error solutions for instant recommendations.
  • Terminal plugins for VSCode, JetBrains, and other IDEs.
  • Collaborative debugging—allowing teams to share debugging sessions with AI-enhanced insights.

TermBuddy is the future of AI-assisted debugging, making error resolution smarter, faster, and seamlessly integrated into developer workflows.

Built With

Share this project:

Updates