aider-desk

Integrates the Aider CLI tool through a Python connector service (Socket.IO-based IPC bridge) to enable three distinct interaction modes: Agent Mode for autonomous multi-step task planning and execution, Code Mode for direct AI-powered code generation and modification, and Context Mode for chat-only interactions. The Python subsystem (resources/connector/connector.py) manages Aider subprocess lifecycle, streams output back to the Electron renderer via Socket.IO, and handles context file management for code modifications.

Implements a multi-step agent system (Agent Architecture in src/main/agent/agent.ts) that decomposes user prompts into executable tasks, manages tool invocation via a schema-based registry, and maintains execution state across multiple LLM calls. The agent system integrates with a Tool Architecture that includes Power Tools (built-in capabilities), Aider Tools (code modification), MCP-based tools (external integrations), and Subagent System for delegating work to specialized agents. Context Management optimizes token usage by selectively including relevant code files, memory, and skills based on task requirements.

Implements a Skills System (Skills System in architecture) that allows agents to define, store, and reuse learned capabilities across tasks. Skills are stored in the Memory System (Memory System in architecture) alongside task learnings, execution results, and context. The system enables agents to query their memory for relevant skills when planning new tasks, improving efficiency and consistency. Skills are persisted in the data store, enabling knowledge accumulation over time.

Implements an Extension System (Extension System in architecture) that allows developers to extend AiderDesk with custom agent behaviors, tools, and integrations without modifying core code. Extensions are loaded dynamically at startup and can hook into the agent execution pipeline, tool registry, and event system. The system provides a plugin architecture with well-defined interfaces for extension developers.

Exposes a REST API (REST API and External Integration in architecture) that allows external applications to programmatically interact with AiderDesk: create projects/tasks, trigger agent execution, query results, and manage settings. The API uses standard HTTP methods and JSON payloads, enabling integration with CI/CD pipelines, webhooks, and third-party tools. Authentication is likely API-key based (details unclear from DeepWiki).

Implements a Localization System (Localization System in architecture) that provides multi-language support for the React UI. Language files are stored in src/common/locales/ (e.g., en.json, zh.json) and loaded dynamically based on user preference. The system supports language switching without app restart, enabling users to work in their preferred language.

Implements isolated execution environments for each task using git worktrees (Git Worktrees and Isolation in architecture), allowing agents to make code changes without affecting the main branch. Each task gets its own worktree, enabling parallel task execution and safe rollback. The Project and Task Management system maintains a hierarchical data structure (src/common/agent.ts) that tracks project metadata, task state, git references, and execution history. Data Persistence stores this state in a local SQLite or JSON-based store, enabling recovery and audit trails.

Implements a provider-agnostic LLM integration layer (LLM Provider Integration in architecture) that abstracts OpenAI, Anthropic, Ollama, and other providers behind a unified interface. The Model Library (llms.txt, updated via GitHub Actions) maintains a curated list of available models with metadata (context window, cost, capabilities). Agent Profiles (Agent Profiles and Configuration) allow users to select and configure specific models per task, with fallback logic if a model is unavailable. The system manages API keys securely via the Settings and Configuration Hierarchy.

Implements a Context Management system (Context Management and Message Optimization in architecture) that analyzes task descriptions and agent state to identify relevant code files, reducing token usage and improving LLM focus. The system uses semantic analysis (likely embeddings-based, though exact implementation unclear from DeepWiki) to rank file relevance, then selectively includes top-K files in the LLM context window. This is combined with a Memory System that stores task learnings, skills, and previous execution results, allowing agents to reuse knowledge across tasks.

Implements a Tool Architecture (Tool Architecture and Approval System in architecture) where tools are defined via JSON schemas, registered in a central registry, and invoked by agents through a standardized calling convention. The system includes an Approval System that intercepts tool calls, displays them to the user, and requires explicit approval before execution. Tool execution is tracked with detailed logs (tool name, arguments, output, execution time), enabling debugging and audit trails. The architecture supports Power Tools (built-in), Aider Tools (code modification), MCP-based tools (external integrations), and Custom Commands.

Integrates the Model Context Protocol (MCP Integration in architecture) to enable agents to discover and invoke tools from external MCP servers. MCP provides a standardized protocol for tools, resources, and prompts, allowing AiderDesk to connect to a growing ecosystem of integrations (databases, APIs, file systems, etc.). The system manages MCP server lifecycle (startup, shutdown, error handling) and translates between AiderDesk's tool schema and MCP's protocol.

Implements the BMAD Workflow System (BMAD Workflow System in architecture), a structured execution model for agent tasks. BMAD likely stands for a specific workflow pattern (e.g., Build-Modify-Analyze-Deploy or similar), providing a standardized way to decompose and execute multi-step tasks. The system is integrated with the UI (BmadInstallPrompt.tsx) and manages task state transitions, tool invocations, and result aggregation.

Implements an EventManager (src/main/events/event-manager.ts) that coordinates real-time updates between the Electron renderer (React UI), main process (Node.js backend), and Python subsystem via Socket.IO and IPC channels. The Message Protocol (Message Protocol in architecture) defines a standard format for inter-process communication. The system enables bidirectional communication: the renderer sends user commands to the main process, which orchestrates agent execution and broadcasts results back to the renderer in real-time.

Implements a hierarchical data structure (Project and Task Management, Data Structures and Type System in architecture) that organizes work into Projects (containing multiple Tasks), with each task tracking execution state, git references, agent configuration, and results. The Data Persistence layer (SQLite or JSON-based store) persists this state, enabling recovery from crashes and audit trails. The Settings and Configuration Hierarchy manages user preferences, API keys, and agent profiles at multiple levels (global, project, task).