Requirements

• Node.js >= 18
• Git
• Python (optional, for compiling certain npm packages)

2. Install dependencies

npm install

Build & Package

```bash

2. Build installer

npm run dist

🚀 Quick Start

⚡ Skills System Usage

Skills are instruction packages that give AI specialized capabilities (e.g., optimization for specific frameworks, complex test writing).

1. Browse & Install: - Open Settings → Skills tab. - Search Market: Click "Search Market" to find community-contributed skills on skills.sh. - GitHub Install: Enter a GitHub repo URL containing a SKILL.md file to clone it directly. - Create Manually: Create an exclusive skill for the current project and edit the generated SKILL.md template. - Use Existing Local Skills: Open the project or global Skills directory from settings, place an existing skill folder there, then refresh the Skills list. 2. How it Works: - Enabled skills are automatically injected into the AI's System Prompt. - When a task touches on the skill's domain, the AI will automatically follow the expert instructions in the skill package. 3. Management: - You can enable/disable specific skills in settings at any time, or click the "Folder" icon to edit the skill's source code directly. - Recognized local skills use a dedicated folder per skill with a SKILL.md file plus optional supporting files such as scripts/, templates/, or data/.

---

Development Environment

```bash

Configure AI Model

1. Click settings icon in bottom-left or press Ctrl+,
2. Select AI provider in Provider tab and enter API Key
3. Select model and save

Supports OpenAI, Anthropic, Google, DeepSeek, Ollama, and custom APIs

Core Module Overview

Renderer UI - React components in src/renderer own panels, editor surfaces, chat, plan views, and user-facing interaction flows.

Agent Runtime - src/renderer/agent is now a first-class runtime subsystem covering orchestration, planning, context flow, tool invocation, and application-level coordination.

State and Session - Renderer-side stores and modes manage UI state, conversation state, checkpoints, branches, and session lifecycle.

Frontend Services - Lightweight client services in the renderer coordinate terminal UX, completions, workspace/session helpers, and requests that cross into Electron APIs.

Renderer Workers - Browser workers handle compute-heavy renderer work such as text/diff processing, while Monaco language workers keep editor language features off the UI thread.

Preload Bridge - src/main/preload.ts exposes a typed contextBridge surface so the renderer can access privileged features without direct Node access.

IPC Handlers - src/main/ipc/*.ts is the contract boundary where renderer requests are validated and routed into main-process capabilities.

Shared Contracts - src/shared contains cross-process types, config, utilities, and shared error definitions used by both renderer and main code.

Main Process Services - src/main owns privileged capabilities: window/app lifecycle, filesystem and shell boundaries, LLM backends, MCP backends, LSP management, indexing, and auxiliary desktop services.

Indexing Worker - src/main/indexing/indexer.worker.ts moves indexing work onto a Node worker thread so parsing, embedding, and vector-store updates do not block the Electron main thread.

🤖 Deep AI Agent Integration

• Three Core Working Modes:
• Chat Mode 💬: Pure conversation mode for quick Q&A and code discussions, direct responses without active tool calls
• Agent Mode 🤖: Intelligent agent mode with single-thread task focus, full file system read/write and terminal execution permissions, ideal for clear development tasks
• Plan Mode 🧠: [NEW] Task orchestration mode supporting multi-turn interactive requirement gathering, automatically creates deep step-by-step execution plans, decomposes complex tasks into multiple sub-tasks with parallel/serial execution, supports task dependency management and progress tracking

• 24+ Built-in Native Core Tools: Building a universal foundation allowing AI to fully take over projects
• 📂 File System Management: read_file (supports single/batch file reading), list_directory (supports recursive traversal)
• ✍️ Smart Code Editing: edit_file (9-strategy intelligent matching), write_file, create_directory, delete_file_or_folder
• 🔎 Full-scale Search Engine: search_files (ultra-fast regex scan, supports | pattern combination), codebase_search (LanceDB vector semantic insight)
• 🧠 Language Service (LSP): find_references, go_to_definition, get_hover_info, get_document_symbols, get_lint_errors (supports force refresh)
• 💻 Sandbox Terminal Control: run_command (supports background execution), read_terminal_output, send_terminal_input (supports Ctrl key combinations), stop_terminal
• 🌐 Knowledge Networking: web_search (multi-strategy fusion), read_url (Jina deep parsing)
• 🤝 Human-like Interaction: ask_user (supports manual approval and confirmation)
• ✨ Task Planning System: create_task_plan, update_task_plan, start_task_execution (supports task dependencies and parallel execution)
• 🎨 UI/UX Design Search: uiux_search (global design aesthetics knowledge base and industry best practices)
• 💾 Project Memory Management: read_memory, write_memory (supports manual approval mechanism)

• Smart Context References:
• @filename - Reference file context with fuzzy matching support
• @codebase - Semantic codebase search based on AI Embedding
• @git - Reference Git changes, auto-fetch diff info
• @terminal - Reference terminal output for quick error analysis
• @symbols - Reference current file symbols, quick navigation to functions/classes
• @web - Web search for latest technical documentation
• Drag & drop files/folders to chat for batch context addition

• Seamless Multi-LLM Switching:
• Supports OpenAI (GPT-4, GPT-4o, o1 series)
• Anthropic Claude (Claude 3.5 Sonnet, Claude 3.7)
• Google Gemini (Gemini 2.0, Gemini 1.5 Pro)
• DeepSeek (DeepSeek-V3, DeepSeek-R1 with thinking process visualization)
• Ollama (local models)
• Custom API (OpenAI-compatible format)
• Quick Model Switching: Dropdown selector at bottom of chat panel, grouped by provider, one-click model switching with custom model parameters

• ⚡ Skills System:
• Plugin-based system based on agentskills.io standard
• Search and install community skill packages from skills.sh marketplace
• Direct installation from GitHub repositories
• Supports project-level and global-level skills, project-level overrides global
• Supports Auto mode (AI auto-determines loading) and Manual mode (requires @skill-name reference)
• Skill packages support YAML frontmatter metadata configuration

• 🔌 Deep MCP Protocol Integration:
• Full implementation of Model Context Protocol standard
• Supports external tools, resources, and prompt extensions
• Built-in OAuth 2.0 authentication flow for third-party service authorization
• Config hot-reload without restart for MCP server updates
• Supports multi-workspace config merging with priority management
• Built-in MCP Registry search for one-click official plugin installation

• 💾 AI Memory & Approval:
• Project-level memory storage supporting long-term and short-term memory
• Manual approval mechanism for AI-written memories to prevent misinformation
• Automatic memory categorization and indexing with semantic search
• Supports memory export/import for team knowledge sharing

• 🎨 Enhanced Response Preview:
• Tool execution results support rich rendering: Markdown, code highlighting, images, tables
• Fluid typewriter animation with real-time AI content generation
• Supports collapse/expand for long content, optimized reading experience
• Thinking process visualization (DeepSeek-R1, Claude 3.7 reasoning models)

• 🪵 Eye Style Log System:
• Redesigned color-highlighted log system
• Separate Main/Renderer process logs for clear debugging
• Supports log level filtering (Debug, Info, Warn, Error)
• Real-time log streaming without refresh

• 🎭 Emotion Awareness System:
• Real-time detection of user coding state (focused, confused, fatigued, etc.)
• Multi-dimensional analysis based on keyboard/mouse behavior and code context
• Intelligent suggestions for break times and task switching
• Personalized baseline learning adapting to different developer habits

🚀 Unique Advantages (vs Cursor/Windsurf/Claude Code)

Adnify builds upon mainstream AI editors with multiple innovative features:

• 🔄 9-Strategy Smart Replace: When AI edits code, 9 fault-tolerant matching strategies (exact match, whitespace normalization, flexible indentation, etc.) ensure successful modifications even with slight format differences, dramatically improving edit success rate

• ⚡ Smart Parallel Tool Execution: Dependency-aware parallel execution - independent reads run in parallel, writes on different files can parallelize, 2-5x speed improvement for multi-file operations

• 🧠 4-Level Context Compression: Progressive compression (remove redundancy → compress old messages → generate summary → Handoff document), supports truly long conversations without context overflow interruption

• 📸 Checkpoint System: Auto-creates snapshots before AI modifications, rollback by message granularity, more fine-grained version control than Git

• 🌿 Conversation Branching: Create branches from any message to explore different solutions, visual management, like Git branches but for AI conversations

• 🔁 Smart Loop Detection: Multi-dimensional detection of AI repetitive operations, auto-interrupt with suggestions, avoids token waste

• 🩺 Auto Error Fix: After Agent execution, automatically calls LSP to detect code errors, immediately fixes issues found

• 💾 AI Memory System: Project-level memory storage, lets AI remember project-specific conventions and preferences

• 🎬 Streaming Edit Preview: Real-time Diff display as AI generates code, preview changes as they're generated

• 🎭 Role-based Tools: Different roles have exclusive toolsets, frontend and backend developers can have different tool capabilities

🙋 Q&A: About the License

Q: Why so many requirements in your license? Looks more complex than MIT?

A: Because I've been hurt before 😭

Seriously, I've seen too many of these operations: - Fork an open-source project, change the name and skin, claim it's "independently developed" - Delete author info and repo address completely, as if the code appeared from nowhere - Sell it for money, take outsourcing projects, don't give the original author a penny, won't even give a star - Even worse, some use it as training materials, students think the teacher wrote it - Companies directly bundle it into their products for sale without mentioning the original author

I'm not against commercialization, really. Want to use it commercially? Come on, send an email, maybe we can even collaborate. But sneakily erasing my name to make money? That's too much, right?

Q: Will I accidentally violate the rules if I use it for personal learning?

A: No! Personal learning, research, graduation projects, side projects—use it freely! As long as you: 1. Don't delete my name and repo address 2. Don't sell it or provide paid services 3. Don't bundle it into other products for sale

That simple, I'm not trying to make things difficult 😊

Q: If I want to use it internally at my company/team, does that count as commercial use?

A: - Small teams (≤5 people) internal use: If it's a startup team or small studio internal tool, not sold externally, generally okay, but recommend sending an email to notify - Company/large team use: Requires written authorization, even for internal tools - External services: Regardless of team size, if providing paid services or selling products externally, commercial authorization is required

If unsure, send me an email, I'm easy to talk to (really). Authorization process is simple, fees are reasonable.

Q: Can I modify the code? Can I distribute it?

A: - Personal modification: Yes, but for personal use only - Distribute modified version: No, unless you get written authorization - Contribute code: Welcome to submit PRs to the official repository, this is encouraged!

Q: Why not just use GPL or MIT?

A: - MIT is too permissive: Allows anyone to use commercially freely, can't protect author's rights - GPL is too strict: Requires derivative works to also be open source, limits reasonable commercial cooperation - Custom license: Protects author's rights while allowing reasonable commercial cooperation, it's a balance

My license core is one thing: You can use it, you can learn from it, but commercial use and team distribution require authorization, don't pretend you wrote it.

Simply put, open source isn't "free for you to abuse," it's "I'm willing to share, but please respect my work."

If you agree with this philosophy, welcome to star ⭐️, that's more important than anything.