DevGate

DevGate is a local-first Developer Context Launcher. It discovers recent projects and development contexts, normalizes them into one model, ranks them, and opens the selected context with an editor, terminal, file manager, or custom command.

The MVP is core-first: the CLI and desktop launcher both reuse the same Rust core for discovery, diagnostics, ranking, cache refresh, and action execution.

MVP Scope

Implemented now:

• Rust workspace with devgate-core and CLI binary devgate.
• devgate list --json
• devgate doctor
• devgate refresh
• devgate open <id> [--action code|cursor|terminal|file-manager]
• Code-like recent provider for VS Code, Cursor, Kiro, VSCodium, and Code OSS on Linux.
• Filesystem scanner provider.
• Manual TOML config provider.
• SQLite local cache.
• Simple fuzzy ranking and path/URI deduplication.
• Basic Tauri 2 desktop launcher window.

Not in the MVP:

• Cloud sync.
• Plugin marketplace.
• AI agent orchestration.
• Complex settings UI.

Repository Layout

crates/devgate-core   Core models, config, providers, ranking, cache, actions
crates/devgate-cli    Rust CLI binary named devgate
apps/desktop          Tauri 2 + React desktop launcher
frontend              Frontend notes and shared UI boundary
docs                  Project documentation

Build and Test

cargo fmt --all -- --check
cargo test
cargo run -p devgate-cli -- list --json
cargo run -p devgate-cli -- doctor

Desktop launcher:

cd apps/desktop
npm install
npm run build
npm run tauri dev

The desktop app exposes a searchable launcher window with provider diagnostics, refresh, and open action buttons. Its Rust commands call into devgate-core; the React UI does not duplicate provider discovery logic.

Configuration

On Linux, DevGate reads:

~/.config/devgate/config.toml

If the file is missing, DevGate uses safe defaults. Example:

[app]
hotkey = "Super+Space"
default_action = "code"

[providers.filesystem]
enabled = true
roots = ["~/Workspace", "~/Projects"]
max_depth = 5

[providers.code_like]
enabled = true

[providers.manual]
enabled = true

[editors.code]
command = "code"
args = ["$path"]

[editors.cursor]
command = "cursor"
args = ["$path"]

[terminal]
command = "gnome-terminal"
args = ["--working-directory=$path"]

[file_manager]
command = "xdg-open"
args = ["$path"]

[[manual.contexts]]
title = "DevGate"
kind = "project"
path = "~/Workspace/sean2077/devgate"
tags = ["launcher", "rust"]

Providers

Code-Like Recents

The code-like provider checks Linux config directories for:

• VS Code
• Cursor
• Kiro
• VSCodium
• Code OSS

For each editor, it checks both:

• User/globalStorage/state.vscdb
• User/sharedStorage/state.vscdb

It reads SQLite key history.recentlyOpenedPathsList and supports URI entries represented as plain strings, { external = ... }, and { scheme, authority, path } objects. Missing databases are ignored; unreadable databases and parse errors appear in devgate doctor.

Filesystem Scanner

The filesystem provider scans configured roots and detects projects with markers such as:

• .git
• .vscode
• *.code-workspace
• package.json
• pyproject.toml
• Cargo.toml
• go.mod
• CMakeLists.txt
• compile_commands.json
• package.xml

On Linux, the default root is ~/Workspace when it exists.

Manual Config

Manual contexts are configured in TOML under [[manual.contexts]]. If no actions are specified, DevGate attaches the configured editor, terminal, and file manager actions for path-backed contexts.

Cache

devgate refresh rebuilds a local SQLite cache at:

~/.cache/devgate/cache.sqlite3

The cache stores discovered context identity and metadata, but executable actions are intentionally stripped from cached rows. devgate list and devgate open may read cached metadata; actions are rehydrated from the current trusted config before they are displayed or executed, so local cache edits cannot become command execution policy.