DevLens

Intelligent codebase visualizer.

Turn any TypeScript, JavaScript, Python, Go, Rust, or Java repository into a living, queryable graph — every node carries a functional summary, a technical summary, and a security assessment.

Join the DevLens Cloud Waitlist →

Click the image to watch the demo

Table of Contents

• What is DevLens?
• Supported languages
• Prerequisites
• Quick Start
• Screenshots
• Why it's fast & cheaper
• Ways to use DevLens
  • Web UI — visual exploration
  • CLI — terminal power
  • Agent Skill — AI-powered understanding
  • MCP Server — for any MCP-compatible AI agent
• How to summarize
• Configuration
• What DevLens understands
• Benchmarks
• Who is this for
• How DevLens compares
• Repository layout
• DevLens Cloud

What is DevLens?

DevLens turns a codebase into a pre-built dependency graph. Instead of reading files one at a time, you (or your AI agent) query the graph: every component, class, function, route, struct, or trait is a node, and every connection is a typed edge (CALLS, IMPORTS, HANDLES, IMPLEMENTS, …). Each node carries:

• Functional summary — what business purpose does this serve?
• Technical summary — how does it work?
• Security assessment — severity + explanation

This is the difference between an AI that re-reads your whole repo every session and an AI that already knows the architecture — architecture reviews, impact analysis, security audits, and onboarding take minutes, not hours.

Typical use cases:

• Onboarding — a developer joining a new team sees the architecture, functional/ technical summaries, modules, and gotchas in minutes, not weeks.
• Impact analysis — before touching a symbol, see its blast radius: what breaks if you change it?
• Security reviews — every node carries a severity-ranked security assessment with real reach.
• PR review — a review packet that explains the diff's impact, tests, and security delta.
• AI agents — give Claude/Cursor/Kilo an MCP server + skill that queries the graph instead of re-reading files.

Supported languages

DevLens parses six languages with native parsers (no AI, no regex, no tree-sitter) and understands their frameworks:

Each repo is analyzed with its language's own parser (Python ast, JavaParser, Go go/ast + go/types, Rust syn, TS compiler API), so edges are real — type-checked interfaces (IMPLEMENTS), framework routes (HANDLES), and ORM data layers (READS_FROM/WRITES_TO).

Prerequisites

Summaries are never generated silently — the CLI and skill ask permission first, and structure-only analysis needs no provider at all.

Quick Start

The fastest way to try the full experience (Web UI + CLI + hot reload) is to clone and run from source. The one-line installers give you the CLI with zero build time.

Option A — Clone & develop (Web UI + CLI together, recommended)

git clone https://github.com/devlensio/devlensOSS.git
cd devlensOSS
bun install

# Development (backend on :3000, hot-reloaded frontend on :3001)
bun dev

# OR production — one command, API + Web UI on a single port (:3000)
bun start

Production bun start builds the frontend only the first time (later runs skip the rebuild unless you pass --rebuild) and serves the Web UI and the backend API on one port. Open the printed URL, paste an absolute repo path, and click Analyze (enable the skip summaries checkbox if you don't want summaries).

Option B — Install the CLI from npm

npm install -g @devlensio/cli

Option C — Install the standalone binary (no Node.js required)

The installers are verbose — they print progress, warnings, errors, and next steps, and automatically add devlens to your PATH (your shell's rc file on macOS/Linux, your user PATH on Windows).

# Linux / macOS
curl -fsSL https://raw.githubusercontent.com/devlensio/devlensOSS/main/scripts/install.sh | sh

# Windows (PowerShell)
irm https://raw.githubusercontent.com/devlensio/devlensOSS/main/scripts/install.ps1 | iex

Customize with environment variables: DEVLENS_VERSION (e.g. v0.5.1), DEVLENS_INSTALL_DIR (install folder), or DEVLENS_NO_PATH=1 to skip the automatic PATH setup.

Using any install — summarize, then explore

cd your-project
devlens init                       # optional — configure your AI provider for summaries
devlens analyze . --summarize      # build the graph + generate AI summaries
devlens overview                   # language, framework, stats, central nodes
devlens find-nodes -t ROUTE        # every route in the app
devlens architecture               # one-command architecture brief
devlens security                   # security flags across the codebase

Want it in your AI agent instead? Jump to Agent Skill.

Screenshots

Interactive graph explorer · node inspector with AI summaries & security risk · focused node subgraph · security findings

Why it's fast & cheaper

A node summary is ~50 tokens. The file it describes is ~2,000. Querying summaries and graph slices (get_blast_radius, get_subgraph) costs a fraction of reading files — humans get answers faster, and AI agents spend dramatically fewer tokens on the same task.

Ways to use DevLens

Pick the interface that fits your workflow:

Web UI — visual exploration

For when you want to see your codebase laid out as an interactive graph.

Open the Web UI, paste your repo path, and explore a force-directed canvas — click any node to see its summaries, callers, callees, and security flags. Search, filter, diff commits across versions. The UI runs on a live server, so opening /graph/<any-new-id> (e.g. clicking a repository card) always renders the graph — even for repos analyzed after the server started.

# Production — one command, UI + API on one port (from the source repo)
bun run start
# → Web UI:  http://localhost:3000

Or from source (see Quick Start): bun run dev (hot reload) or bun run start (production). The Web UI runs from the source tree — it is not bundled into the installed CLI binary.

CLI (@devlensio/cli) — terminal power

For scripts, CI, and answers fast without leaving the terminal. Every command supports --json for piping into scripts, -v/--verbose for diagnostics, and --quiet for minimal output.

npm install -g @devlensio/cli

Analyze & summarize