Forem: Naman Khater

I built a bug reporting system into my VS Code extension — here's how it works

Naman Khater — Tue, 14 Apr 2026 02:11:42 +0000

One thing I learned early while building CIPHER-Local — a VS Code extension that indexes your codebase and serves code intelligence to AI assistants via MCP — is that beta users won't file bugs if it's even slightly annoying to do so.

So instead of hoping people would manually dig through logs and paste them into a GitHub issue, I built the entire reporting pipeline into the extension itself. Every error is captured, structured, and one click away from becoming a useful bug report.

Here's how the system works, and how you can use it if you're trying CIPHER-Local.

Every error gets journaled automatically

Under the hood, CIPHER-Local catches every exception and writes it to an error_journal table in its local SQLite database. Errors are grouped by module and operation, deduplicated, and tracked with a repeat count.

The extension is organized into layers, and the module prefix tells you exactly where the problem happened:

l01-vscode — Extension lifecycle, commands, status bar
l02-indexer — Tree-sitter parsing, workspace file scanning
l03-store — SQLite database reads and writes
l04-query — Symbol and chunk query layer
l05-mcp — The MCP HTTP+SSE server
l06-embedding — ONNX model loading and BM25 fallback

When errors exist, the status bar shows something like ⚠ CIPHER: 3 errors. That badge is your entry point.

Path 1: The built-in flow (recommended)

This is the fastest way to report a bug — three steps, takes about 30 seconds.

Step 1 — Open the error viewer.
Click the ⚠ CIPHER: N errors badge in the status bar, or run Ctrl+Shift+P → CIPHER: View Errors.

A QuickPick panel opens showing all errors grouped by module. Each entry shows an icon (error/warning/info), the operation name like indexFile or mcpStart, the first 60 characters of the message, the timestamp, and how many times it repeated.

Click any entry to see the full detail — message, sanitized stack trace (file paths replaced with <path> so nothing private leaks), and structured context like the language being parsed, file extension, tool name, and duration.

Step 2 — Copy diagnostics.
Select Copy Diagnostics from the QuickPick footer, or run Ctrl+Shift+P → CIPHER: Copy Diagnostics.

This puts a structured report on your clipboard that looks like this:

Your AI coding assistant is flying blind — here's how to fix it

Naman Khater — Tue, 14 Apr 2026 02:07:36 +0000

Let me paint a picture you probably recognize.

You're working in a 200-file project. You ask Copilot to refactor a function. It confidently rewrites it — but breaks three callers in other files because it didn't know they existed. You ask Cursor to trace a bug through your service layer. It guesses the function signatures instead of looking them up.

The AI isn't dumb. It's just working without a map.

Why AI assistants struggle with real codebases

Most AI coding tools operate on what's directly visible — your open tab, maybe a few related files the editor pulls in. They don't have a symbol table. They don't know your dependency graph. They can't answer "where is this function defined?" or "what calls this method?" without scanning every file from scratch.

This is fine for small scripts. It falls apart on anything with real architecture.

MCP changes the game

MCP (Model Context Protocol) lets AI assistants call external tools during a conversation. Instead of the AI guessing at your code structure, it can ask a tool: "find me every reference to processPayment" or "what does the UserService class look like?"

The problem is — who builds these tools? Most MCP servers are built for APIs and databases. Not for code.

I built one for code

CIPHER-Local is a free VS Code extension that turns your workspace into a queryable code intelligence backend. It parses your code with Tree-sitter, indexes everything into SQLite, and exposes 7 MCP tools your AI assistant can call.

Here's what that looks like in practice:

Before CIPHER-Local:

"Refactor the calculateDiscount function"
→ AI rewrites it, misses 4 callers, introduces a type mismatch

After CIPHER-Local:

AI calls resolve_symbol("calculateDiscount") → gets the full definition
AI calls find_references("calculateDiscount") → sees all 4 callers
AI calls get_file_context("pricing.ts") → understands the surrounding module
→ Refactors correctly, updates all call sites

The AI goes from pattern-matching on vibes to working with actual structural knowledge.

The 7 tools your AI gets

Tool	What it does
`search_symbols`	Find functions, classes, types by name pattern
`resolve_symbol`	Get the full definition and source of any symbol
`find_references`	Find every import and call site for a symbol
`semantic_search`	BM25 full-text search across your indexed code
`get_dependencies`	See package dependencies (npm, pip, cargo, go.mod, etc.)
`get_file_context`	Get all symbols defined in a specific file
`list_namespaces`	Discover all indexed workspaces

These work with GitHub Copilot, Cursor, Claude Code, and Claude Desktop — anything that speaks MCP.

What gets indexed

13 languages out of the box: TypeScript, JavaScript, Python, Java, Go, Rust, C, C++, C#, Ruby, PHP, Swift, and Kotlin. All parsed with Tree-sitter WASM grammars — no native dependencies, no compilation step.

Nothing leaves your machine

This matters. CIPHER-Local runs entirely on localhost. Your code index lives in a SQLite file in VS Code's storage. There's no cloud sync, no API key, no account creation. It's MIT licensed and the source is on GitHub.

For anyone working on proprietary code, internal tools, or just uncomfortable with cloud-based indexing — this is built for you.

The honest state of things

This is a beta (v0.1.3) built by a solo developer. It works well on the projects I've thrown at it, but I know there are edge cases I haven't hit. Some things I'm actively working on:

ONNX-based vector search for smarter semantic queries
Better handling of monorepos
More granular symbol relationship mapping

If you try it and something breaks, that's genuinely useful feedback. Open an issue or just tell me what language/framework you were using.

How I gave GitHub Copilot real code intelligence with a local MCP server

Naman Khater — Sun, 12 Apr 2026 14:33:57 +0000

The problem: Copilot doesn't know your codebase

If you've used GitHub Copilot or Cursor on a large project, you've probably noticed that AI suggestions get worse as your codebase grows. The AI can see your open files, maybe grep through some others, but it doesn't actually understand the structure — where functions are defined, what calls what, how modules connect.

I ran into this building a 16-service TypeScript platform. Copilot would hallucinate function signatures, miss cross-file references, and suggest imports that didn't exist. The AI was powerful, but context-blind.

The fix: structured code context via MCP

MCP (Model Context Protocol) is a standard that lets AI assistants call external tools. Instead of giving the AI raw file contents, you can give it structured tools — "search for symbols matching X", "find all references to function Y", "get the dependency tree for this project."

I built CIPHER-Local, a VS Code extension that:

Indexes your workspace using Tree-sitter (13 languages)
Stores symbols, chunks, references, and dependencies in a local SQLite database
Serves 7 MCP tools over HTTP+SSE on localhost

When your AI assistant needs code context, it calls these tools instead of scanning files blindly.

How it works in practice

Install the extension, open a project, and CIPHER-Local automatically:

Parses every supported file with Tree-sitter
Extracts functions, classes, interfaces, types, constants
Maps imports and call references
Indexes everything into SQLite with FTS5 full-text search
Starts an MCP server on a random localhost port
Auto-configures .github/copilot-instructions.md so Copilot knows to use MCP tools

Now when Copilot needs to understand your code, it can call search_symbols to find a function by name, resolve_symbol to get its definition, or find_references to see everywhere it's used. Structured data, not grep results.

What's supported

Languages: TypeScript, JavaScript, Python, Java, Go, Rust, C, C++, C#, Ruby, PHP, Swift, Kotlin

MCP tools:

search_symbols — find symbols by name pattern
resolve_symbol — get definition + source snippet
find_references — find import/call sites
semantic_search — BM25 full-text search
get_dependencies — package dependencies by ecosystem
get_file_context — all symbols for a file
list_namespaces — discover indexed workspaces

AI assistants: GitHub Copilot, Cursor, Claude Code, Claude Desktop — anything MCP-compatible.

Privacy: everything stays local

No cloud. No API keys. No account. The index lives in a SQLite file in your VS Code global storage. Nothing leaves your machine. MIT licensed.

Try it

Search "CIPHER-Local" in VS Code extensions or install from:
https://marketplace.visualstudio.com/items?itemName=Naman09Khater.ecip-local

This is a beta from a solo developer — I'd genuinely appreciate feedback on what languages to prioritize, what breaks, and what MCP tools would be most useful.

GitHub: https://github.com/Enterprise-Code-Intelligence-Platform/ecip-local