DoCode

⚠️ Attribution (Important)

DoCode is a fork/evolution of Understand-Anything by Lum1104.

This project builds upon the excellent foundation laid by Lum1104's Understand-Anything. All core analysis concepts, graph generation techniques, and initial architecture credit goes to the original author. DoCode extends this work with enhanced dashboard features, improved documentation, and additional analysis capabilities.

Original Project: https://github.com/Lum1104/Understand-Anything
Original Author: Lum1104

🤔 What is DoCode?

DoCode (formerly evolving from Understand-Anything) is a modern code intelligence platform that transforms how developers understand, navigate, and maintain complex codebases. It automatically scans repositories and generates interactive knowledge graphs that visualize:

Structural relationships between files, functions, classes, and modules
Dependency graphs showing import chains and coupling
Domain-specific flows for business logic visualization
Interactive dashboards for exploring code relationships

Core Philosophy

Fast: Analyzes 500+ files in ~1 second
Visual: Interactive graphs instead of static documentation
Flexible: Works with GitHub repos, local folders, or ZIP archives
Extensible: Plugin architecture for custom analyzers

🎯 Why DoCode? (Problem Statement)

Modern codebases are increasingly complex:

Microservices with hundreds of repositories
Monorepos with thousands of files
Legacy code with poor documentation
Rapid team changes leading to knowledge loss

Traditional tools fail because:

Static documentation gets outdated quickly
Code search lacks relationship context
Dependency analysis is fragmented
New team members struggle to onboard

DoCode solves this by:

Automatically generating living documentation via code analysis
Visualizing actual code relationships, not just file structures
Providing interactive exploration instead of static docs
Enabling quick impact analysis for changes

✨ Key Features

1. Structural Code Analysis

Parses ASTs (Abstract Syntax Trees) to extract:
- Functions, classes, methods, variables
- Import/export relationships
- Call hierarchies
- Type annotations and interfaces
Supports multiple languages: JavaScript, TypeScript, Python, Java, C#, Go, Rust

2. Knowledge Graph Generation

Creates nodes for code entities (files, functions, classes)
Creates edges for relationships (imports, calls, extends, implements)
Generates both structural and domain-specific graphs
Outputs standard formats: JSON, GraphML, Cytoscape.js

3. Interactive Dashboard

Search: Full-text search across all code entities
Filter: Filter by type, language, complexity
Explore: Click nodes to see details and relationships
Navigate: Jump to source code directly from graph
Export: Save graphs as images or JSON

4. Flexible Input Sources

Input Type	Example	Notes
GitHub Repository	`https://github.com/4shil/Docode`	Public & private repos (with auth)
Local Folder	`~/projects/my-app`	Analyzes current state
ZIP Archive	`project.zip`	Good for one-off analyses
Git URL	`git@github.com:user/repo.git`	Clones and analyzes

5. Performance

Speed: ~1 second for 500 files (depending on hardware)
Incremental: Only re-analyzes changed files
Caching: Stores analysis results for quick reloads
Parallel: Uses worker threads for concurrent analysis

📸 Screenshots

Dashboard Main View

The main dashboard view showing code knowledge graph visualization

Graph Visualization

Interactive graph showing relationships between code entities

Detail Panel

Detailed view of selected code entity with relationships

🚀 Quick Start

30-Second Quick Start

# Clone the repository
git clone https://github.com/4shil/Docode.git
cd DoCode

# Install dependencies
pnpm install

# Build core package
cd docode/packages/core && pnpm build && cd ../../

# Run analysis on DoCode itself
pnpm run analyze -- --target . --output .understand-anything/

# Start the dashboard
cd docode/packages/dashboard && pnpm dev

Then open http://localhost:3000 to see your code graph!

🛠️ Detailed Installation Guide

Prerequisites

Node.js ≥ 18.x (LTS recommended)
pnpm ≥ 8.x (Package manager)
Git (for cloning repositories)
Python 3 (optional, for some analyzers)

Step 1: Install pnpm (if not installed)

# Using npm
npm install -g pnpm

# Or using corepack (Node.js ≥ 16.9)
corepack enable
corepack prepare pnpm@latest --activate

Step 2: Clone the Repository

git clone https://github.com/4shil/Docode.git
cd DoCode

Step 3: Install Dependencies

pnpm install
# This installs all workspace packages (core, dashboard, etc.)

Step 4: Build Core Package

cd docode/packages/core
pnpm build
cd ../../  # Return to root

Step 5: Verify Installation

pnpm run analyze -- --help
# Should show help text for the analyzer

📚 Documentation Pages Guide

1. Getting Started

What's covered:

Prerequisites and installation
First analysis (GitHub repo, local folder, ZIP)
Starting the dashboard
Quick examples with expected output
Troubleshooting common issues

When to use: New users should start here.

2. Usage Guide

What's covered:

Advanced analysis options
Configuration files
CI/CD integration
Performance tuning
Custom analyzers
Batch processing

When to use: After getting started, to learn advanced features.

3. Dashboard

What's covered:

Dashboard features and UI components
Keyboard shortcuts
Search and filtering
Graph interaction
Settings and customization
Export options

When to use: To master the interactive dashboard.

4. Architecture

What's covered:

Project structure deep dive
Data flow diagrams
Core engine internals
Plugin system
API endpoints
Design decisions

When to use: Contributors and developers extending DoCode.

5. API Reference

What's covered:

Core API methods
Data formats (JSON schemas)
TypeScript types
HTTP endpoints (if using server mode)
Event system
Extension points

When to use: Integrating DoCode programmatically.

6. Contributing

What's covered:

Development setup
Coding standards
Pull request process
Testing guidelines
Issue reporting
Community guidelines

When to use: Want to contribute code or documentation.

🏗️ Architecture Overview

DoCode uses a monorepo architecture with three main packages:

Docode/
├── homepage/              # Astro-based documentation site (you are here)
│   ├── src/pages/        # Documentation pages (MDX)
│   ├── public/           # Static assets
│   └── dist/             # Build output (deployed to GitHub Pages)
│
├── docode/                # Main workspace (pnpm)
│   └── packages/
│       ├── core/         # Analysis engine (TypeScript)
│       │   ├── src/
│       │   │   ├── analyzer/   # Language-specific analyzers
│       │   │   ├── graph/      # Graph generation logic
│       │   │   └── output/     # Export formats
│       │   └── dist/           # Compiled output
│       │
│       └── dashboard/    # React-based visualization (Vite + React)
│           ├── src/
│           │   ├── components/ # UI components
│           │   ├── graph/      # Cytoscape.js integration
│           │   └── state/      # State management
│           └── dist/           # Production build
│
├── docs/                  # Documentation source (MDX)
├── scripts/               # Build and analysis scripts
└── .understand-anything/  # Generated knowledge graphs (legacy name)

Data Flow

Input → GitHub URL / Local path / ZIP
Analysis → Core engine parses code, extracts entities
Graph Generation → Creates nodes and edges
Output → JSON + Dashboard visualization
Interaction → User explores via dashboard

🎯 Use Cases

1. New Team Member Onboarding

Quickly understand project structure
Visualize dependencies and relationships
Find key files and entry points

2. Legacy Code Understanding

Map undocumented codebases
Identify dead code and unused dependencies
Plan refactoring efforts

3. Impact Analysis

See what breaks when changing a function
Understand downstream dependencies
Plan safe refactoring

4. Code Review Enhancement

Visualize PR changes in context
Understand relationship impact
Generate review documentation

5. Architecture Decision Support

Visualize current vs target architecture
Identify architectural smells
Plan microservices extraction

❓ Frequently Asked Questions

Q: Is DoCode a replacement for IDE features?

A: No, it complements IDEs. While IDEs provide local code intelligence, DoCode gives you a global view of relationships across the entire codebase or multiple repositories.

Q: How is DoCode different from Sourcegraph?

A: Sourcegraph is a search tool with some code intelligence. DoCode focuses specifically on visual graph exploration and relationship mapping, which is more intuitive for understanding complex dependencies.

Q: Can I analyze private repositories?

A: Yes! For GitHub, provide a personal access token. For local folders, just provide the path.

Q: Does DoCode modify my code?

A: Never. DoCode is read-only — it only analyzes, never writes to your source files.

Q: How do I add support for a new language?

A: Check the Contributing Guide for creating custom analyzers. DoCode's plugin architecture makes it straightforward.

Q: Why is the output folder named `.understand-anything/`?

A: Historical compatibility with the original Understand-Anything project. This will be renamed to .docode/ in a future release.

🔧 Troubleshooting

Issue: Analysis fails with "No files found"

Solution:

Check that the target path is correct
Ensure the language is supported
Try with --verbose flag for detailed logs

Issue: Dashboard won't start (port 3000 in use)

Solution:

# Kill process on port 3000
npx kill-port 3000

# Or use a different port
pnpm dev -- --port 3001

Issue: pnpm install fails

Solution:

# Clear pnpm cache
pnpm store prune

# Reinstall
rm -rf node_modules pnpm-lock.yaml
pnpm install

Issue: Build errors in core package

Solution:

cd docode/packages/core
pnpm clean
pnpm install
pnpm build

Issue: Dashboard shows "No data"

Solution:

Ensure analysis completed successfully
Check that .understand-anything/ folder exists
Verify JSON files are valid (use jq to check)

🤝 Contributing

We welcome contributions! Here's how to get started:

Quick Contribution Steps

Fork the repository
Clone your fork: git clone https://github.com/YOUR_USERNAME/Docode.git
Create branch: git checkout -b feature/your-feature
Make changes and commit: git commit -m "feat: add your feature"
Push to your fork: git push origin feature/your-feature
Open PR against 4shil/Docode:main

Development Setup

# After cloning
pnpm install

# Run core tests
cd docode/packages/core && pnpm test

# Run dashboard dev server
cd ../dashboard && pnpm dev

# Run docs site locally
cd ../../../homepage && pnpm dev

Coding Standards

TypeScript: Strict mode enabled
Formatting: Prettier + ESLint
Commits: Conventional Commits (feat:, fix:, docs:, etc.)
Tests: Jest for core, Vitest for dashboard

See Contributing Guide for full details.

📄 License

This project is licensed under the MIT License — see the LICENSE file for details.

Important: The original Understand-Anything project by Lum1104 is also MIT licensed. DoCode maintains this license compatibility.

🙏 Credits

Original Project

Understand-Anything by Lum1104
- Repository: https://github.com/Lum1104/Understand-Anything
- Core analysis concepts, graph generation techniques

DoCode Evolution

Maintainer: 4shil
Enhancements: Improved dashboard, comprehensive documentation, GitHub Pages site
Repository: https://github.com/4shil/Docode

Built With

Astro - Documentation site
React - Dashboard UI
Cytoscape.js - Graph visualization
pnpm - Package management
TypeScript - Type-safe development

💬 Support & Community

Issues: GitHub Issues
Discussions: GitHub Discussions
Documentation: https://4shil.github.io/Docode/

Last Updated: May 2026
Version: 0.1.0 (evolving from Understand-Anything)

Name		Name	Last commit message	Last commit date
Latest commit History 15 Commits
.docode		.docode
.github/workflows		.github/workflows
.vscode		.vscode
assets		assets
docode		docode
docs		docs
homepage		homepage
scripts		scripts
.gitignore		.gitignore
.npmrc		.npmrc
CONTRIBUTING.md		CONTRIBUTING.md
LICENSE		LICENSE
README.md		README.md
package.json		package.json
pnpm-lock.yaml		pnpm-lock.yaml
pnpm-workspace.yaml		pnpm-workspace.yaml
tsconfig.json		tsconfig.json

Folders and files

Latest commit

History

Repository files navigation

DoCode

⚠️ Attribution (Important)

📖 Table of Contents

🤔 What is DoCode?

Core Philosophy

🎯 Why DoCode? (Problem Statement)

✨ Key Features

1. Structural Code Analysis

2. Knowledge Graph Generation

3. Interactive Dashboard

4. Flexible Input Sources

5. Performance

📸 Screenshots

Dashboard Main View

Graph Visualization

Detail Panel

🚀 Quick Start

30-Second Quick Start

🛠️ Detailed Installation Guide

Prerequisites

Step 1: Install pnpm (if not installed)

Step 2: Clone the Repository

Step 3: Install Dependencies

Step 4: Build Core Package

Step 5: Verify Installation

📚 Documentation Pages Guide

1. Getting Started

2. Usage Guide

3. Dashboard

4. Architecture

5. API Reference

6. Contributing

🏗️ Architecture Overview

Data Flow

🎯 Use Cases

1. New Team Member Onboarding

2. Legacy Code Understanding

3. Impact Analysis

4. Code Review Enhancement

5. Architecture Decision Support

❓ Frequently Asked Questions

Q: Is DoCode a replacement for IDE features?

Q: How is DoCode different from Sourcegraph?

Q: Can I analyze private repositories?

Q: Does DoCode modify my code?

Q: How do I add support for a new language?

Q: Why is the output folder named .understand-anything/?

🔧 Troubleshooting

Issue: Analysis fails with "No files found"

Issue: Dashboard won't start (port 3000 in use)

Issue: pnpm install fails

Issue: Build errors in core package

Issue: Dashboard shows "No data"

🤝 Contributing

Quick Contribution Steps

Development Setup

Coding Standards

📄 License

🙏 Credits

Original Project

DoCode Evolution

Built With

💬 Support & Community

About

Topics

Resources

License

Contributing

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Uh oh!

Contributors

Q: Why is the output folder named `.understand-anything/`?

Packages