Requirements

The engines and packageManager fields in package.json declare the required versions, while preinstall (scripts/ensure-pnpm.js) rejects other package managers. Use the pinned Node version and pnpm 11.22.0 before installing.

4. Install dependencies

pnpm install

mise install # reads mise.toml

Build & Package

```bash

2. Build installer

pnpm 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 the editor, Agent surfaces, Plan Workbench, terminal, previews, and user-facing interaction flows.

Agent Runtime - src/renderer/agent provides the shared execution kernel for Agent and Plan task workers, including model routing, context flow, tool policies, approvals, budgets, and recovery.

Plan Runtime - The Plan domain models requirements, task dependencies, execution state, artifacts, validation, and history independently from the UI, while reusing the same proven Agent kernel for each task.

State and Session - Renderer-side stores manage UI state, threads, checkpoints, branches, and session lifecycle. A dedicated session-storage process persists SQLite history, while hot/cold message windows bound the amount of history loaded into the UI.

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 window/app lifecycle, filesystem and shell permissions, command scheduling, LLM and MCP backends, LSP management, notifications, and coordination of isolated services.

Isolated Service Processes - Code indexing, session storage, asset storage, and content processing run in Electron utility processes started on demand. Each workspace has an index service shared by its windows; parsing and SQLite workers run inside that service. See Process Isolation.

🤖 Two Purpose-Built AI Workflows

Adnify intentionally exposes two modes. The former standalone Chat mode has been merged into Agent, so questions, investigation, and implementation share one continuous context instead of forcing users to choose between conversation and action.

• Agent Mode 🤖 — execute directly
• Ask questions, inspect a codebase, edit files, run commands, search documentation, and verify results in one thread.
• Permission-aware tools, checkpoints, diagnostics, loop detection, and recovery keep autonomous work observable and reversible.
• Progressive context compression and summary/handoff support long-running tasks without losing key decisions.

• Plan Mode 🧠 — review the work before it runs
• A four-stage workbench guides Requirement Review → Plan Review → Run Center → Result Review.
• The planner produces dependency-aware tasks with expected artifacts, priorities, role/model allocation, and sequential or parallel execution paths.
• Structural checks catch dependency cycles, missing prerequisites, and parallel write conflicts before execution.
• Each task runs in an isolated worker thread on the shared Agent kernel. You can inspect progress, open task threads, handle approvals, pause/resume execution, request changes, and accept the final result.

3. Enable Corepack so pnpm matches packageManager

corepack enable

Choose a Workflow

Agent Mode is the default workspace for questions and implementation. Ask about the project, attach context with @, or describe a change; Agent can inspect files, use tools, generate diffs, run verification, and report the result in the same thread. There is no separate Chat mode.

Plan Mode is designed for larger or higher-risk work. Use it when you want to review requirements, dependencies, ownership, models, artifacts, and execution order before any task runs.

Context References: Type @ to select files, or use @codebase, @git, @terminal, @symbols, and @web for special context.

Inline Edit: Select code and press Ctrl+K, then describe the change without leaving the editor.

🙋 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.