DevMine

Universal AI Agent for Your Computer

Works with any model. Reads, writes, runs, searches, analyzes — without limits.

Website · Install · Quick Start · Features · Comparison · Architecture · Contributing

What is DevMine?

DevMine is a desktop AI agent built on Tauri v2 (Rust + TypeScript). It's not tied to one provider — connect OpenAI, Anthropic, DeepSeek, GLM, Ollama, LM Studio, or any OpenAI-compatible API. Everything runs locally, your data never leaves your machine (unless you use cloud models).

Two modes:

• Desktop UI — graphical app with chat, file previews, session history
• Terminal CLI — full terminal interface (Ink + React)

DevMine vs The World

6 Unique Features

1. Pattern DNA — Your Code Style, Learned Automatically

DevMine scans your project and extracts a compact "DNA fingerprint" — naming conventions, import patterns, error handling style, framework choices. This DNA is injected into the system prompt, so the AI writes code that looks like yours.

2. Error Memory Bank — Never Makes the Same Mistake Twice

Every compilation error, type mismatch, and runtime failure is recorded with a Jaccard similarity fingerprint. When the AI encounters a similar context, it gets a warning: "Last time you did X, it failed because Y". Errors decay with a 7-day half-life.

3. Shadow Compilation — Silent Auto-Fix

Before you see any code, DevMine silently compiles it in the background. Semicolons, unused vars, missing imports — fixed automatically in up to 3 iterations without a model round-trip. You only see clean, compiling code.

4. Autonomous Skills — AI That Teaches Itself

DevMine doesn't just use built-in tools — it creates new skills on the fly. Need a CSV analyzer? A security scanner? The AI builds it, saves it, and reuses it next time. 11 built-in skills + 21 design skills out of the box.

5. Parallel Sub-Agents — 5 Tasks at Once

Instead of editing files one by one, DevMine spawns sub-agents that work simultaneously. "Add tests for all files in src/services/" → 5 agents in parallel → 5x faster.

6. Context Phoenix — Never Loses Context

When context fills up, DevMine doesn't freeze or hallucinate. A 5-tier compaction system (trim → compact → aggressive → nuclear) automatically strips media, summarizes tools, and keeps the conversation alive. You never have to restart.

Install

From Source

git clone https://github.com/xuviga/DevMine.git
cd DevMine

# Install dependencies
npm install

# Build TypeScript
npm run build

# Build UI
npm run build:ui

# Run in dev mode (Desktop)
npm run tauri dev

# Or terminal version
npm start

Requirements

• Node.js 20+
• Rust 1.70+ (via rustup)
• Tauri CLI v2 (npm install -g @tauri-apps/cli)

Quick Start

On first launch, DevMine walks you through setup:

╭─────────────────────────────────────╮
│  Welcome to DevMine!                │
│                                     │
│  1. Choose a provider               │
│  2. Enter your API key              │
│  3. Pick a model                    │
│                                     │
│  Done — ready to work.              │
╰─────────────────────────────────────╯

Or manually — create ~/.devmine/config.json:

{
  "providers": [
    {
      "name": "my-openai",
      "baseUrl": "https://api.openai.com/v1",
      "apiKey": "sk-...",
      "format": "openai-compatible"
    }
  ],
  "defaultProvider": "my-openai",
  "permissionMode": "ask"
}

Features

22 Built-in Tools

DevMine doesn't just generate text — it acts:

Supported Providers

Permission Modes

God Mode — 3 Escalation Tiers

Design Mode — Built-in HTML Designer

Create landing pages, presentations, prototypes, wireframes with 21 built-in design skills. Export to PDF, PPTX, standalone HTML, or send to Canva.

Skills System

DevMine creates custom skills on the fly:

You: "Make a skill for CSV analysis"

DevMine: ✓ Skill "csv-analyzer" created
         - Automatic CSV parsing
         - Statistics: mean, median, stddev
         - Outlier detection
         - Distribution visualization

Skills persist and are reused across sessions. 11 built-in + 21 design skills included.

Memory

Three-layer persistent memory that survives sessions:

1. Identity — your preferences, name, project context
2. Semantic — knowledge graph with entities and relations
3. Checkpoint — state snapshot every 5 exchanges

Plus Error Memory Bank — the agent remembers its mistakes and doesn't repeat them.

MCP (Model Context Protocol)

Connect external tool servers via the MCP standard:

{
  "mcpServers": [
    {
      "name": "my-database",
      "command": "npx",
      "args": ["@modelcontextprotocol/server-postgres"],
      "env": { "DATABASE_URL": "postgresql://..." }
    }
  ]
}

MCP tools appear automatically — the agent uses them as native tools.

Telegram Gateway

Run the agent on a server and chat via Telegram:

devmine serve --config devmine-server.json

Supports streaming responses, Telegram ID authorization, /reset and /status commands, webhook + polling.

Architecture

devmine-desktop/
├── src-tauri/              # Rust backend (Tauri v2)
│   ├── src/
│   │   ├── main.rs         # Entry point
│   │   ├── lib.rs          # Plugin + command registration
│   │   ├── tools.rs        # Native tools (files, shell, SSH)
│   │   └── ...
│   └── Cargo.toml
│
├── src/                    # TypeScript core
│   ├── core/               # Agent loop + query engine
│   ├── tools/builtins/     # 22 built-in tools
│   ├── connect/            # Provider adapters (OpenAI, Anthropic, GLM)
│   ├── services/           # Pattern DNA, Error Memory, Shadow Compiler
│   ├── extensions/         # Skills system + Design skills
│   ├── prompts/            # System prompts + God Mode directives
│   ├── mcp/                # Model Context Protocol client
│   ├── memory/             # Persistent memory system
│   ├── server/             # Telegram Gateway
│   ├── swarm/              # Swarm Intelligence coordinator
│   └── ui/                 # Desktop UI (React + Vite)
│
├── package.json
└── tsconfig.json

Tech Stack: Tauri v2 (Rust) · React 18 + TypeScript + Vite · Zustand · Ink · Zod · Vitest

Contributing

1. Fork the repo
2. Create your feature branch (git checkout -b feature/amazing)
3. Commit your changes (git commit -m 'Add amazing feature')
4. Push to the branch (git push origin feature/amazing)
5. Open a Pull Request

Development

npm install           # Install dependencies
npm run build         # Build TypeScript
npm run typecheck     # Type check
npm test              # Run tests
npm run dev:ui        # Dev server for UI
npm run tauri dev     # Tauri dev mode
npm run tauri build   # Production build

License

Apache-2.0 — use freely.