DevProjex

DevProjex 📁🌳

🏆 Officially Selected by the Avalonia UI Team for the App Showcase

[Downloads] [Build] [License] [Last commit] [Platforms]

Turn a real codebase into clean, AI-ready context — and see exactly what you're sending.

DevProjex turns any folder or codebase into clean, ready-to-use context for AI chats, code reviews, and documentation. Use it as a GUI, a TUI, a CLI, or an MCP server for AI agents — whatever fits your workflow.

Choose what you need in an interactive file tree, check the result in a live preview, then export it as ASCII, Markdown, JSON, or XML. Need more than text? Export a real copy of your project — a clean folder or ZIP file — with the same filters applied.

🔒 Read-only analysis and telemetry-free by design. DevProjex does not upload your project contents or collect telemetry.

App Demo 🖼️

Download 🚀

Download from Microsoft Store: 👉 DevProjex

Latest GitHub release: 👉 https://github.com/Avazbek22/DevProjex/releases/latest

Install via WinGet (Windows): winget install OlimoffDev.DevProjex

All install options per OS are covered in Docs/Installation.md.

Run without installing

These headless channels are available from release v5.2. Until the v5.2 packages have completed their first publication, use the direct GitHub release binary.

npx devprojex tree .dnx devprojex tree ../DevProjex tree .

The npm and NuGet packages contain the CLI, TUI, and MCP server, but not the desktop application. See Docs/Installation.md for the Node/.NET requirements and supported platforms.

Release automation also prepares direct headless archives and a non-root Docker image; their commands and availability boundary are documented in Docs/Installation.md.

Why DevProjex? 💡

Copying files into a chat window one by one doesn't scale. CLI tools pack a whole project fast, but you can't see what you're sending before it's sent.

DevProjex works differently — visual, precise, and local-first:

• You see what leaves your project — file tree, live preview, token estimate
• You control what leaves it — Smart Ignore, Git modes, secret and private-data redaction, name filters, saved profiles
• You get more than text — a real project copy as a folder or ZIP

Use it for

• AI assistants — clean input for ChatGPT, Claude, DeepSeek, Qwen, Kimi
• AI agents — Claude Code, Cursor, or any MCP client inspects your project through a read-only, always-redacted server
• CI pipelines — fail a build when secrets would leak into packed context, without ever printing the values
• Restricted environments where AI agents, remote indexing, or IDE plugins aren't allowed
• Code reviews — share structure and only the files that matter
• Large codebases — pull out one module instead of the whole repo
• Teaching — explain a project's architecture to a teammate or student

Get started

1. Open or drop a project folder.
2. Choose folders, files, filters, ignore rules, and output mode.
3. Preview, then copy, export, or run the same workflow from the terminal.

Works with any language, repository, or project structure.

Feature overview ✨

Choose and control

• Smart Ignore — hides build output, dependency folders, and caches, and checks for evidence before hiding anything. How it works ↓
• Hide Secrets — masks detected credential values in everything you export. How it works ↓
• Hide private data — optionally masks emails, IPs, MACs, phones, and user paths. How it works ↓
• Code compression — keeps declarations and signatures, empties implementation bodies; pure code gets ~3× smaller. How it works ↓
• Strip comments and strip blank lines — syntax-aware cleanup across 20 language packs, without modifying source files
• File tree with checkboxes, search, and name filters
• Git-aware scopes for .gitignore, tracked files, staged files, all current changes, or a ref-to-ref diff

Preview and export

• Live preview (tree / content / both) before you copy or export
• Scrollbar markers show search matches and redaction findings at a glance
• Export as ASCII, Markdown, JSON, or XML
• Save to file or clipboard — tree only, content only, or both
• Export a clean copy of your project to a folder or ZIP archive

Workflow

• GUI, TUI, CLI, and MCP server — the same engine, four ways to work
• Git tools built in: clone by URL, switch branches, update cached copies
• Local profiles remember your settings per project
• Live counters for lines, characters, and estimated tokens
• Progress bar with safe cancellation

Interface

• Light, dark, and system themes, with transparency and blur where supported
• Platform-native keyboard shortcuts — ⌘-based on macOS, Ctrl-based on Windows and Linux
• Tree context menu — reveal in the file manager, copy paths or transformed contents, select one item, expand or collapse a branch
• Localization in 20 languages
• Stays smooth even on very large folders

DevProjex vs the alternatives ⚖️

_{Based on publicly documented features, last verified September 2026. DevProjex no-install package channels are available from v5.2.}

Project Copy Export 📦

Use File → Export project → To folder… or To ZIP archive… to create a separate copy of your current selection.

Project copies respect your chosen root folders, file types, ignore rules, and checked items. If nothing is checked, the whole current tree is exported. Directory structure, binary files, and included empty folders are preserved.

When Hide Secrets or Hide private data is enabled, detected values in text files are replaced. Binary files remain unchanged. This result is intentionally not a byte-for-byte copy and may not build or run.

The source project is never modified, and the result can't be written inside it. The same workflow is available through devprojex export project.

Command Line ⚙️

DevProjex isn't only a desktop context builder. The same app runs from the terminal too, for repeatable, script-friendly project analysis and AI-context export.

devprojexdevprojex open . --previewdevprojex tree .devprojex tree https://github.com/owner/repo --branch maindevprojex analyze . --format jsondevprojex analyze . --hide-secrets --hide-private-data --findings --fail-on-findingsdevprojex export context . --format markdown -o ../devprojex-context.mddevprojex export context https://github.com/owner/repo -o -git diff --name-only | devprojex export context . --select-from - -o -devprojex export project . --as zip --hide-secrets -o ../devprojex-submission.zip$ devprojex export project . --as zip -o - > devprojex-submission.zipdevprojex analyze . --git-mode tracked --exclude smart-ignoredevprojex search Configure . --symbolsdevprojex related src/App.cs --direction bothdevprojex profile save . --hide-secrets ondevprojex cache update https://github.com/owner/repo

What the CLI adds

• Scriptable exports for CI pipelines — JSON reports, stdout output, deterministic files
• Git repository URLs as project sources — analyze, export, open, or start the TUI on a repository straight from its URL through a managed clone cache (devprojex cache, devprojex recent)
• A redaction pre-flight for CI — --findings lists rule, category, file, and source line (never the values), and --fail-on-findings fails the pipeline when findings exist
• Composable selection — pipe a file list from git diff or any tool into --select-from -
• Project search and relations — devprojex search finds text, --regex patterns, or declarations by name with --symbols; devprojex related lists the files a file uses and the files that use it
• Documented aliases and short flags (export ctx, export proj, -f, -n, -q) plus devprojex help <command> and shell completion for bash, zsh, fish, and PowerShell
• A keyboard-first Terminal Workspace for interactive work, no desktop app needed
• A searchable Action Palette to find any workflow fast
• The same Git filtering, exclusions, and profiles as the desktop app

See Docs/CommandLine.md for the full command reference, and Docs/TerminalWorkspace.md for the interactive terminal interface.

MCP Server 🤖

DevProjex ships a built-in secure Model Context Protocol server (on the official C# MCP SDK) that turns any local folder or Git repository into safe, token-efficient codebase context for AI agents — Claude Code, Claude Desktop, Cursor, Windsurf, VS Code, or any MCP client — through the same engine as the GUI, TUI, and CLI:

devprojex mcp --root /path/to/project

Connect from the Desktop MCP → Live context or MCP → Standard submenu, from Terminal Workspace with mcp connect <client> [live|standard], or from the CLI with devprojex mcp connect . --client <client> (standard mode unless --mode live is given). Desktop registers the selected server mode and opens Claude Code, Codex, Cursor, or VS Code; the chosen submenu controls whether the registration follows the checked tree. Terminal Workspace registers without opening another terminal, while the CLI opens the client only when --open is given. Claude Code and Codex are configured through their installed command; Cursor and VS Code receive a project-local .cursor/mcp.json or .vscode/mcp.json. Existing files are merged without changing other servers. Use --print when only a manual configuration fragment is needed.

Live context makes the tree checked in the DevProjex window the agent's focus through the shared local project profile; the window's filters remain the limit of what it can read. The compact MCP menu, between File and Git, has Live context, Standard, Journal, and documentation entries. Live context uses --live; Standard does not follow the window selection. After a successful connection, an optional PATH dialog can offer the platform-appropriate terminal setup. The window title names an active client or session count, and saved focused paths are restored on reopen. Live mode has three separate rules: focus keeps tree, search, analysis, dependency, and pack operations inside the checked selection; access boundaries still enforce the configured filters and secret protection, while a directly named readable file may be returned with an outside-focus notice; saved results stay pinned to the revision that created them and must be rebuilt explicitly after the window selection changes.

For a first-call check, inspect DevProjex with /mcp in Claude Code or run codex mcp list. Then ask: “Through DevProjex, show the tree of the current selection.” That call appears in the agent journal.

Eight read-only tools cover the whole workflow: list_projects, get_tree, analyze, search_project, related_files, get_file, pack_context, and read_pack. related_files answers "what does this file actually use, and who uses it" from a static dependency index over up to 16 seed files, so following a thread never widens the selection. pack_context and related_files store an oversized result as a session pack; read_pack reads it back in line ranges instead of flooding the agent's context. Long operations report standard MCP progress notifications.

The local agent journal records metadata and counts for MCP sessions, never file bodies or detected secret values. Read it from the GUI, TUI, or CLI, and export a Markdown or JSON context receipt showing calls, delivered paths, and totals.

The server enforces hard security boundaries on top of DevProjex's read-only design:

• Read-only by design — tools cannot modify project files or run project code; network access is disabled unless --allow-remote is explicitly enabled for Git URL projects
• Secret redaction is always on in MCP mode and has no off switch — not in the server flags, not in the tool schemas, so neither a config mistake nor the agent itself can turn it off
• Optional private-data masking via devprojex mcp --hide-private-data, mirroring the CLI flag
• Root jail — local access is pinned to startup roots; opt-in remote Git URL checkouts are pinned on first use; symlink and junction escapes are rejected
• Agent paths and globs can only narrow the selection, and the .git administrative area is never exposed. By default the agent sees the repository the way Git does — Smart Ignore and .gitignore apply, while Dockerfile, .github/, dot-files, and empty files stay visible — and every tree ends with a trusted line naming the active filters. Widening or narrowing that view is your startup decision, never the agent's by default: a --exclude baseline, the widest-baseline --unrestricted preset, or per-call agent control behind the opt-in --allow-agent-exclusions flag
• Returned file contents are wrapped in untrusted-data markers to resist prompt injection

The missing off switch is a control guarantee, not a detection guarantee. DevProjex detects common secret formats, but detection is heuristic; review each pack before publishing it outside your environment.

Built for agent efficiency. Trees default to compact markdown, content declares the root once and uses relative paths — no tokens wasted on scaffolding. With max_tokens, files are considered in deterministic selection order; each is included if its estimated transformed-content tokens fit the remaining budget, otherwise it is reported as skipped and packing continues. top_files shows where the tokens go, git_scope narrows get_tree, analyze, pack_context, search_project, or related_files to staged files, current changes, or a ref-to-ref diff, and profile switches between built-in defaults, your saved Desktop selections, or a portable profile file.

Want to audit what the agent gets? Open the same project in the GUI: the engine and redaction pipeline are shared, and filters match when the same profile and parameters are used.

How DevProjex compares as an MCP server

_{Based on publicly documented features; Repomix v1.17.0 source and documentation verified September 6, 2026.}

See Docs/McpServer.md for client setup, the full tool reference, and the security model.

Safety boundaries 🛡️

DevProjex keeps normal processing and MCP tools read-only. The only write inside an opened project is an explicit Cursor or VS Code MCP connection, which atomically creates or updates .cursor/mcp.json or .vscode/mcp.json:

• Does not otherwise edit, rename, move, or delete files in the opened source project
• Does not commit, merge, push, or switch branches in the source repository opened from the user's filesystem. Branch operations are limited to application-owned cached clones.
• Does not include binary file contents in text or AI-context output; redaction rules do not scan binary data
• Writes generated files and project copies only to destinations you choose, outside the source project

How Smart Ignore Works 🧠

Smart Ignore is a local, deterministic filter — not an AI model, and not one big blacklist for the whole folder. It knows where each project starts and ends, and applies the right rules only inside that project.

It knows project boundaries. DevProjex finds project markers like .csproj, package.json, pyproject.toml, go.mod, or Cargo.toml. Rules for that stack (node_modules, bin/obj, virtual environments, build caches) apply only inside the project that owns them. A .NET service won't hide bin in an unrelated folder next to it, and a frontend app won't hide node_modules somewhere it doesn't belong.

It checks before it hides anything. Folder names like build, dist, or vendor can mean generated files — or real source code. Smart Ignore looks for real signs first: package files, compiler output, known build layouts. If there's no clear sign, the folder stays visible.

It keeps monorepos separate. Each nested project — frontend, backend, tools, docs — is filtered on its own, based on its own markers. Nothing crosses over between unrelated parts of your workspace.

Git modes — a separate setting, not part of Smart Ignore:

You stay in control. Smart Ignore, the Git mode, and basic filters (hidden files, dot-files, empty folders) all work together and can be turned on or off one by one. "Ignored" means excluded from the current view, copy, or export — it never deletes anything from your project.

📖 Full technical details — signature matching, worktree handling, edge cases — are in Docs/SmartIgnore.md.

How Code Compression Works 🗜️

An AI rarely needs every implementation line — it needs the shape of your code. Compression keeps declarations, signatures, fields, and class structure, and empties named implementation bodies:

// Before — what's in your file (unchanged on disk)private Command BuildMcpCommand(){    var command = new Command("mcp", L("Terminal.Command.Mcp"));    // … ~40 more lines of implementation}
// After — what goes into the packed contextprivate Command BuildMcpCommand(){ }

Measured on DevProjex's own C# sources (619 files), the packed context shrinks from 5.4 MB to 1.7 MB — a 69% cut, roughly 3× smaller. On a mixed repository the saving is lower, because compression only touches code, never test fixtures, JSON assets, or documentation.

It covers 14 languages, parsing with Tree-sitter grammars and applying DevProjex's own per-language rules about what must survive (properties in Kotlin, val/var in Scala, free lambdas everywhere), and it is deliberately conservative: a file it can't process safely stays complete. Comment and blank-line stripping extend the same syntax engine to 20 packs in total — the 14 plus six comments-only packs such as HTML, CSS, YAML, and XML project files. The same transformed content feeds token metrics, context documents, and folder/ZIP exports, in the GUI and via --compress-code in the CLI.

📖 Per-language rules and edge cases are in Docs/CodeCompression.md.

How Hide Secrets and Hide Private Data Work 🔒

Two independent layers. Both replace values inside the output — they never delete a file and never modify your project.

Hide Secrets finds credential values — API keys, tokens, connection strings — and masks each one where it stands, keeping the file and all surrounding code:

var botToken = "110201543:AAHdqTcvE…";                          // in your filevar botToken = "DEVPROJEX_REDACTED[telegram-bot-api-token#1]";  // in the export

Detection runs a pinned, reviewed Gitleaks rule set on DevProjex's own engine, and one secret never costs you the whole file. Findings are marked on the Preview scrollbar, and a false positive can be excluded per match right in Preview. You enable it with one switch in the GUI or --hide-secrets in the CLI; in MCP mode it is forced on with no off switch. For pipelines, --findings prints rule, file, and line — never the value — and --fail-on-findings fails the build.

Hide private data is the second, optional layer for personal traces: emails, global IPs, local-user paths, MAC addresses, and international phone numbers become DEVPROJEX_REDACTED[email#1], [ipv4#1], [local-user#1], and so on — the same placeholder for the same finding on every surface, so exported code stays consistent. It is off by default: real projects are full of version strings that look like IPs and sample emails that are not personal. Turn it on per profile in the GUI, or with --hide-private-data in the CLI and MCP.

📖 Detection rules and edge cases: Docs/HideSecrets.md · Docs/HidePrivateData.md

Documentation 📚

Installation · Smart Ignore · Hide Secrets · Hide private data · Code Compression · Command Line · Terminal Workspace · MCP Server · Agent Journal · Related files · Contributing · Code of Conduct

Tech stack 🧩

[.NET 10] [WinGet] [Repository size] [Tests]

• .NET 10
• Avalonia UI (cross-platform)
• Tree-sitter parsing · Gitleaks rule source · official MCP C# SDK — attributions in THIRD-PARTY-NOTICES.md
• Clean Architecture layers (Kernel / Application / Infrastructure / Terminal / Avalonia)
• JSON-based resources (localization, icon mappings, presets)
• 20,000+ automated tests (unit + integration + terminal + UI), run on Windows, Linux, and macOS

Build from source

git clone https://github.com/Avazbek22/DevProjex.gitcd DevProjexdotnet build -c Releasedotnet test

Contributing 🤝

Issues and pull requests are welcome. Good places to start: UX, performance tuning, tests, localization, documentation & screenshots. Not sure where? Check issues labeled good first issue.

See CONTRIBUTING.md for details.

Support 💛

[Support DevProjex on Boosty]

License (Apache-2.0) 📄

DevProjex is licensed under the Apache License 2.0 — free to use, modify, and distribute, with an explicit patent grant. Copyright (c) 2025–present Avazbek Olimov. See LICENSE for details.

Code signing: Free code signing provided by SignPath.io, certificate by SignPath Foundation. See the code signing policy.