DEV Community: Sagar Kashyap

I Built a VS Code Extension That Tells You Every Node.js Package's Go Equivalent

Sagar Kashyap — Mon, 15 Jun 2026 04:53:38 +0000

We've all been there.

You're migrating a Node.js project to Go (or Rust, or Python — pick your poison), and you hit the first import:

import express from 'express';
import axios from 'axios';
import jsonwebtoken from 'jsonwebtoken';
import bcrypt from 'bcrypt';
import sequelize from 'sequelize';

And now the real work begins: Googling every single package to find its equivalent in Go.

"What's the Go equivalent of Express?" → Gin? Echo? Fiber? Chi?

"What replaces Axios in Go?" → net/http? resty? req?

"What's the Go bcrypt?" → golang.org/x/crypto/bcrypt? But wait, how do I import that?

Multiply this by 30–50 packages in a real codebase and you've just burned an entire afternoon on Stack Overflow tabs.

I got tired of it, so I built something

PackagePal is a free VS Code extension that does one thing really well:

Hover over any import → instantly see the top 3 equivalent packages in your target language.

No browser tabs. No Googling. No context switching. Just hover.

How it works (30-second version)

Open any source file (JavaScript, Python, Go, Rust, Java, C++, Ruby, PHP, Swift, Kotlin — 13 languages supported)
Set your target language (e.g., "Go") via the status bar
Hover over any import statement
PackagePal uses Gemini AI to find the top 3 equivalents with:
- 📦 Package name and description
- 💻 Ready-to-paste code snippet
- 📘 Direct link to official documentation

That's it. No configuration files, no setup ceremony.

A real example: migrating Express to Go

Let's say you're converting a Node.js REST API to Go. Here's what happens when you hover over express:

PackagePal shows you:

#	Go Equivalent	Why
1	gin-gonic/gin	Most popular, great middleware ecosystem, fast
2	labstack/echo	Clean API, built-in middleware, good docs
3	gofiber/fiber	Express-inspired syntax (easiest transition from Node)

Each suggestion includes a code snippet showing how to set up a basic server — so you can immediately start coding instead of reading "Getting Started" guides.

The sidebar: your migration dashboard

Beyond hover, PackagePal has a sidebar explorer (click the 🚀 icon in your Activity Bar) that:

Auto-scans every import in your current file
Shows a tree view of every package and its equivalents
Click to expand code snippets and documentation links

It's like having a migration cheat sheet that updates itself as you work through your codebase.

Why I built this

I was migrating a personal project from Node.js/Express to Go last year. The actual code translation wasn't hard — Go's syntax is straightforward if you know any C-family language.

The painful part was the dependency mapping. My package.json had 47 packages. For each one, I had to:

Google "[package name] equivalent in Go"
Compare 3–4 options on Reddit/GitHub
Read the README to understand the API
Write the import statement

This took me two full days just to map dependencies — before writing a single line of Go.

I figured: this should be one hover away, not a research project.

The tech behind it

PackagePal uses Google's Gemini AI (you bring your own free API key from Google AI Studio) to generate context-aware suggestions. It's not a static lookup table — it understands:

What the source package does (not just name matching)
The ecosystem conventions of the target language
Which alternatives are actively maintained in 2026

This means it works for niche packages too, not just the big ones.

Your key, your control

PackagePal uses a Bring Your Own Key (BYOK) model:

Get a free Gemini API key (takes 30 seconds)
The key is stored securely in VS Code's native Secret Storage
Only package names are sent to the API — zero source code leaves your machine

No accounts, no telemetry, no tracking.

What languages are supported?

Source / Target Languages
JavaScript, TypeScript, Python, Go, Rust, Java, Kotlin, C#, C++, Ruby, PHP, Swift

You can migrate in any direction — Python → Rust, Java → Go, Ruby → Python, whatever your project needs.

Try it in 60 seconds

Install PackagePal from the VS Code Marketplace
Run Set Gemini API Key from the command palette (get a free key at aistudio.google.com)
Set your target language in the status bar
Open any file with imports and hover

That's it. If it saves you even one Google search, I'd love to hear about it in the comments 👇

What's next

I'm actively working on:

Workspace batch scan — scan all files in your project at once
Migration reports — export a complete dependency mapping as a document
Multi-model support — choice of AI models beyond Gemini

If you have ideas or feedback, open an issue on GitHub or drop a comment below.

Links:

If PackagePal helps you, I'd really appreciate a ⭐ on the Marketplace — it helps other developers discover it!

Check it out. An AI powered migration assistant.

Sagar Kashyap — Mon, 08 Jun 2026 09:43:42 +0000

Sagar Kashyap

Jun 8

I Built a Tool That Finds Package Equivalents Across Programming Languages

#ai #programming #productivity #opensource

3 min read

I Built a Tool That Finds Package Equivalents Across Programming Languages

Sagar Kashyap — Mon, 08 Jun 2026 09:36:43 +0000

TL;DR: I built PackagePal — paste in any package from any language, pick your target language, and AI instantly finds the equivalent. No more Googling "what's the Node.js version of Python's requests?"

The Problem That Drove Me Crazy

You know that moment when you're migrating a project — or just jumping between ecosystems — and you hit a wall trying to find the right package?

I do. Every time.

# You're used to this in Python
import requests
response = requests.get("https://api.example.com/data")

And you move to Node.js and think: "Okay, what do I use here? axios? node-fetch? got? undici?"

So you Google it. You find a Stack Overflow thread from 2019. Half the answers recommend packages that are now deprecated. You open 6 tabs. 20 minutes later you're still not sure which one is the current best choice.

This wasn't a once-in-a-while thing for me. It happened constantly — switching between Python, JavaScript, Go, and Ruby on different projects. I was wasting real hours on a problem that felt completely solvable.

So I built PackagePal.

What PackagePal Does

PackagePal uses AI to understand what a package actually does — its purpose, not just its name — and finds the best equivalent in whatever language you're moving to.

The key insight: this isn't a lookup table. A simple mapping of requests → axios misses context. What if you're using requests for its session management? Or its retry logic? PackagePal surfaces options and explains why each one is a good match.

Example searches people use it for:

Python's pandas → JavaScript
Ruby's devise → Node.js
Go's cobra → Python
JavaScript's lodash → Go

Just type the package, pick the target language, and get results in seconds.

👉 Try it: packagepal.dev

How I Built It

Tech Stack

🤖 AI: Gemini Pro — handles the semantic understanding of what a package does and why an alternative matches
⚛️ Frontend: React + TypeScript
⚙️ Backend: Node.js + TypeScript on Google Cloud
⚡ Caching: Redis — so repeat searches (e.g., "requests → Node.js" gets searched constantly) are instant

The Architecture Decision That Mattered Most

Early on I tried a pure lookup-table approach: maintain a database of known equivalents. It fell apart immediately. There are thousands of packages across dozens of ecosystems, and the "best" equivalent changes as the ecosystem evolves.

The AI approach was the right call. Instead of asking "what package has a similar name?", Gemini gets asked "what does this package do, and what package in the target language serves the same purpose best?" The results are dramatically better.

The Redis caching layer was a fun addition — popular searches like requests → Node.js or lodash → Python get cached so users get sub-100ms responses for anything that's been searched before.

The Hardest Part

Honestly? Prompt engineering. Getting Gemini to return structured, consistent results that I could reliably parse and display took a lot of iteration. The model would sometimes return one suggestion, sometimes five, in varying formats. I eventually settled on a structured output format with explicit instructions for how many alternatives to return and what information to include for each.

What I Learned

1. Semantic search beats keyword search for this use case
A mapping table would need constant manual maintenance. AI handles edge cases, niche packages, and new packages automatically.

2. Caching is underrated for AI apps
AI inference isn't free. For a tool where the same queries come up repeatedly, Redis made the product both faster and cheaper to run.

3. Ship early
I spent too long polishing before launching. The feedback I got in the first week of real users pointed to things I never would have caught in isolation.

What's Next

More languages — currently covers the most popular ones; expanding to Rust, Swift, Kotlin, and more
Version context — surfacing whether a recommended package is actively maintained
Reverse search — "I found this package, what does it do?"
VS Code extension — hover over an import and see cross-language equivalents inline

Try It & Let Me Know What You Think

PackagePal is live at packagepal.dev. It's free to use.

If you try it, I'd genuinely love to hear:

Did it find the right equivalent for your use case?
What languages or packages should I prioritize next?
Any features you'd want?

Drop a comment below or reach out directly. I read everything.

Built by Sagar Kashyap. If you found this useful, sharing it with a dev friend who migrates between stacks would mean a lot 🙏