DevScope – Backend & API Analyzer

Understand your backend without manually tracing routes, controllers, services, middleware, models and DTOs.

DevScope analyzes your backend directly inside VS Code and builds a structured view of your API architecture.

Overview

DevScope performs static AST analysis of your backend codebase to give you complete architectural visibility without running your code or relying on external services.

With DevScope, you can inspect:

• Endpoints: Verbs, routes, paths, and source code line declarations
• Controllers: Class methods and handler functions
• Services: Service classes and methods used across routes
• Middlewares: Route-level authentication and validation handlers
• Models: Database entities, interfaces, and types
• DTOs: Data Transfer Objects and request body schemas
• Relationships: Call chains and component dependencies
• API Documentation: Automated Markdown reference view
• OpenAPI Structure: Standard OpenAPI 3.0 specification output

All analysis and visualization happen directly inside Visual Studio Code.

Features

• Automatic Backend Analysis: Instantly inspect your backend project architecture.
• Endpoint Discovery: Resolve HTTP methods, routes, paths, and source line references.
• Controller Detection: Map route handlers to controller methods and functions.
• Service Detection: Discover service layer dependencies and methods.
• Middleware Detection: Track authentication and custom middlewares attached to endpoints.
• Model Detection: Map database models, interfaces, and entity types.
• DTO Detection: Inspect Data Transfer Objects and request schemas.
• Relationship / Navigation Mapping: Jump directly from any tree element to its exact declaration line in source files.
• API Documentation Generation: Create structured Markdown reference documentation (API.md).
• OpenAPI Generation: Produce standard OpenAPI 3.0 specification structures (openapi.json).
• Automatic Re-Analysis on Save: Refresh analysis automatically when relevant files are modified and saved.
• Source Navigation: One-click code jump from tree view items to source code.
• Private Extension Storage: Store generated documentation securely in VS Code extension storage without polluting workspace folders.
• Sensitive-File Exclusion: Hardened security rules to automatically ignore environment variables, credentials, and private keys.

Backend Overview

DevScope provides a high-level overview of the analyzed backend including framework, files, routes, endpoints, controllers, services, middleware and OpenAPI paths.

Explore Your Backend Architecture

Developers can inspect controllers, services, middleware, models and DTOs without manually navigating the entire project codebase.

Automatic API Documentation

DevScope generates structured API documentation directly from the analyzed backend codebase.

OpenAPI Structure

Detected API information is represented through an OpenAPI-oriented structure with paths, operations, parameters, request bodies and responses when available.

Automatic Analysis on Save

After the initial analysis, DevScope can automatically re-analyze relevant backend files when they are saved.

• Debounced Processing: 800 ms debounce prevents unnecessary overhead during rapid typing.
• Background Execution: Re-analysis runs asynchronously without locking the editor.
• Non-Intrusive Notifications: Auto-refreshes seamlessly in the background without pop-up distractions.
• Live Refresh: Automatically updates the TreeView and extension storage documentation.

Privacy & Security

DevScope is built with a local-first architecture:

• 100% Local Execution: Performs static code analysis entirely on your local machine.
• Zero Cloud Code Uploads: Source code is not sent to external servers or cloud services.
• Sensitive File Exclusion: Automatically ignores .env, .env.*, *.pem, *.key, *.crt, credentials.*, secrets.*, and SSH keys.
• Clean Workspace: Generated documentation files are stored in VS Code extension-managed storage rather than creating an api-docs/ directory in your project workspace.

Getting Started

1. Install DevScope from Visual Studio Code Marketplace.
2. Open a supported backend project folder in VS Code.
3. Click the DevScope icon in the Activity Bar.
4. Click Analyze Project (or run DevScope: Analyze Project from the Command Palette).
5. Explore the generated backend architecture in the interactive view or click any element to navigate to source code.

After your initial analysis, saving relevant backend files automatically keeps the view and documentation up to date.

Current Support

DevScope v0.1.0 is currently optimized for:

• Express
• JavaScript
• TypeScript

Additional backend frameworks may be supported in future versions.

Settings

DevScope provides configuration options via VS Code Settings:

• devscope.autoAnalyze: Controls whether DevScope automatically re-analyzes the backend after relevant files are saved. (Default: true)

{
  "devscope.autoAnalyze": true
}

Requirements

• Visual Studio Code: Version ^1.85.0 or higher.

Current Limitations

• Framework Scope: Framework support is currently limited to Express backends in v0.1.0.
• Static Analysis Bounds: Highly dynamic runtime-generated routes (e.g. routes generated via dynamic string concatenation or runtime evaluation) may not be resolved statically.
• Re-analysis Scope: Version 0.1.0 performs full project re-analysis after relevant file saves rather than incremental delta analysis.

Roadmap

• Additional backend frameworks
• Improved relationship visualization
• Incremental analysis
• Expanded OpenAPI inference

License

DevScope is proprietary software.
See the LICENSE file for details.