phodal/auto-dev
45.3
Weak · 13 November 2026
305.2k
lines of production code
Kotlin
with TypeScript
6
measurements over time
What this system is
Xiuper is an AI-native, multi-agent development platform built on Kotlin Multiplatform that provides cross-platform support for JVM, Android, iOS, JavaScript, and WebAssembly. It enables autonomous coding, code review, and document analysis through a modular agent architecture that integrates with external LLMs, MCP servers, and various static analysis tools. The system features a unified code graph engine for multi-language parsing, a custom DevIns language for structured agent workflows, and robust session management with automatic context compression.
How it got here
2023–2025 — Xiuper rebrand and multi-platform expansion
206 changes.
The project rebranded from AutoDev to Xiuper, establishing a Kotlin Multiplatform architecture to support JVM, Android, iOS, JS, and WASM targets. This period focused on building a comprehensive multi-agent development platform with specialized agents, a custom DevIns language, and extensive cross-platform tooling for file systems, shell execution, and code analysis.
2026 — WebAgent and ACP infrastructure
7 changes.
This period focused on establishing the structural foundation for cross-platform browser automation through multi-platform stubs and core E2E testing models. Simultaneously, it introduced the Agent Client Protocol (ACP) infrastructure and external CLI agent support, enabling bidirectional communication with tools like Claude Code and Codex.
Features
Add A2A agent integration and new design system assets
The plugin now supports connecting to external A2A (Agent-to-Agent) servers, allowing users to discover, view details for, and test remote agents directly from the IDE via new service classes and UI panels. Additionally, a new design system has been introduced with centralized color definitions (AutoDevColors), icons (AutoDevIcons), and a dynamic localization bundle (AutoDevBundle) that respects user language settings, ensuring consistent visual styling and internationalization across the plugin.
mpp-idea/mpp-idea-core · high confidence
Add Android platform support with shell execution capabilities
This change introduces the Android platform implementation for the core agent module. It adds a Platform object that identifies the environment as Android, retrieves OS details (version, API level, device model), and provides system paths like the log directory. Additionally, it implements a DefaultShellExecutor for Android, allowing the application to execute shell commands via ProcessBuilder with support for timeouts, working directories, environment variables, and command validation to prevent dangerous system operations.
mpp-core/src/androidMain/kotlin/cc/unitmesh/agent · high confidence
Add Claude Code client with stream-json protocol support
Introduces a new JVM-based client for the Claude Code binary, enabling communication via the stream-json protocol over standard I/O. This implementation parses streaming JSON-line messages to render thinking, text, and tool-use content in real-time, while handling session management and process lifecycle. The client configures the Claude Code process with specific flags such as \--include-partial-messages\ for streaming fidelity, sets a default permission mode of \acceptEdits\ to auto-approve safe operations, and explicitly disables the \AskUserQuestion\ tool as it is incompatible with the non-interactive stream-json mode.
mpp-core/src/jvmMain/kotlin/cc/unitmesh/agent/claude · high confidence
Add GLM CogView image generation service with in-flight request deduplication
Users can now generate images from text prompts using the GLM CogView API (models cogview-3-flash and cogview-4) via the new ImageGenerationService. The service supports dynamic model switching through the centralized LLMServiceManager and includes in-flight request deduplication to prevent redundant API calls for identical prompt and size combinations.
mpp-core/src/commonMain/kotlin/cc/unitmesh/llm/image · high confidence
Add GitHub Copilot integration and multimodal image analysis capabilities
Users can now select GitHub Copilot as an LLM provider, with the JVM implementation automatically registering the client provider on first use if available. The system also introduces multimodal image analysis via the Tencent GLM-4.6V vision model, featuring automatic image compression to reduce costs, optional upload to Tencent COS for large files, and support for both streaming and non-streaming image understanding requests.
mpp-core/src/jvmMain/kotlin/cc/unitmesh/llm · high confidence
Add GitHub issue tracking integration with caching support
The agent now supports fetching issue details from GitHub repositories via a new \GitHubIssueTracker\ implementation, which parses repository URLs and authenticates using optional personal access tokens. This change introduces a unified \IssueTracker\ interface and \IssueInfo\ data model that includes built-in caching capabilities, allowing the system to track cache timestamps and display cache age to users. A \NoOpIssueTracker\ is also provided for scenarios where issue tracking is not configured.
mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/tracker · high confidence
Add JavaScript implementation for chat session storage
A new JS-specific implementation of the session storage mechanism has been added for the \mpp-core\ module. This change enables chat sessions to be persisted in the browser's \localStorage\ under the key \autodev\_chat\_sessions\, allowing users to retain their conversation history across page reloads in web environments.
mpp-core/src/jsMain/kotlin/cc/unitmesh/devins/llm · high confidence
Add JavaScript platform support for code graph parsing
Introduces the \JsCodeParser\ and \CodeGraphFactory\ implementation for the JS target, enabling code analysis on JavaScript/Wasm environments. The parser leverages \web-tree-sitter\ to parse source code into \CodeNode\ and \CodeRelationship\ structures, supporting import extraction for Java/Kotlin and TypeScript/JavaScript, and allowing the construction of a \CodeGraph\ from multiple files.
mpp-codegraph/src/jsMain · high confidence
Add JavaScript-friendly LLM service wrapper and platform-specific executors
Introduces \JsKoogLLMService\ in \JsExports.kt\ to provide a JavaScript-compatible API for the LLM service, exposing methods like \streamPrompt\ and \sendPrompt\ via Promises and handling provider configuration mapping. Additionally, \ExecutorFactory.js.kt\ implements platform-specific behaviors for the JS target, explicitly disabling GitHub Copilot auto-registration and blocking executor creation to enforce async initialization patterns.
mpp-core/src/jsMain/kotlin/cc/unitmesh/llm · high confidence
Add JavaScript/Node.js Git operations implementation
The platform-specific Git operations layer now includes a new implementation for the JavaScript environment (Node.js). This change introduces \GitOperations.js.kt\, which enables core Git capabilities such as cloning repositories, retrieving modified files, fetching recent commits (including support for multi-line commit messages), and computing diffs. This implementation allows the agent to perform Git-related tasks within JS-based runtimes, complementing existing platform implementations.
mpp-core/src/jsMain/kotlin/cc/unitmesh/agent/platform · high confidence
Add Node.js-based file system implementation for JavaScript environments
The JavaScript platform now uses a high-performance file system implementation backed by the Node.js \fs\ module, enabling native file read, write, existence checks, and recursive search operations. This implementation includes environment detection to ensure operations only run in Node.js (falling back gracefully in browsers) and exposes a JavaScript-friendly API via \JsFileSystem\ and \JsFileSystemFactory\ for direct consumption by JS consumers.
mpp-core/src/jsMain/kotlin/cc/unitmesh/devins/filesystem · high confidence
Add Swift MCP client bridge for iOS integration
Introduces a new Swift-based bridge (McpClientBridge) in the iOS module that exposes Model Context Protocol (MCP) client functionality to Kotlin/Native via Objective-C interoperability. This addition enables iOS applications to discover tools from configured MCP servers, execute those tools with JSON arguments, and monitor server connection statuses directly from the Swift layer.
mpp-core/src/iosMain/swift · high confidence
Add WASM Git support with log parsing and resilient cloning
This change introduces WebAssembly-based Git operations for the core platform, enabling Git functionality in WASM environments. It adds a classic git log parser to convert raw log output into structured commit information, implements Git operations via the wasm-git (libgit2) module, and includes a multi-proxy CORS cloning strategy with exponential backoff retries to handle network reliability issues in browser contexts.
mpp-core/src/wasmJsMain/kotlin/cc/unitmesh/agent/platform · high confidence
Add WASM-specific in-memory session storage implementation
Introduces a new WASM-specific implementation of the session storage interface that uses an in-memory cache instead of localStorage, as localStorage is not yet available in the WASM environment. This ensures chat sessions are persisted within the current session for WASM targets, with a distinct storage path identifier to differentiate it from other platforms.
mpp-core/src/wasmJsMain/kotlin/cc/unitmesh/devins/llm · high confidence
Add WebAssembly (WASM-JS) platform support for core agent tools
This change introduces a new WebAssembly-JS target for the core agent tooling, providing platform-specific implementations for file system access, code parsing, HTTP fetching, and shell execution. The WASM-JS file system is an in-memory implementation that supports directory trees, metadata, and pattern matching but is volatile across page reloads. Code parsing is handled by a dedicated WasmJsCodeParser, while HTTP operations utilize Ktor's JS engine. Shell execution is explicitly unsupported in this environment and throws a 'not supported' error, and the GitIgnore parser is a stub that ignores all files. This enables the agent to run in WebAssembly environments with appropriate limitations.
mpp-core/src/wasmJsMain/kotlin/cc/unitmesh/agent/tool · high confidence
Add WebAssembly platform support and export platform API
The core platform detection logic now supports WebAssembly, introducing a new \Platform\ implementation that identifies the environment as 'WebAssembly' and provides defaults for OS info, shell, and directories suitable for browser-based execution. To enable JavaScript interop, a dedicated export module exposes these platform details (such as name, OS info, and timestamp) as top-level JavaScript functions, allowing external scripts to query the runtime environment.
mpp-core/src/wasmJsMain/kotlin/cc/unitmesh/agent · high confidence
Add WebAssembly platform support for agent configuration and logging
The core module now supports the WebAssembly (Wasm) platform by introducing platform-specific implementations for agent configuration and logging. For configuration, the \McpServerLoadingState\ implementation uses \kotlinx.datetime.Clock\ to provide the current time in milliseconds. For logging, the platform-specific initialization is set to use console logging by default, and the log directory returns a placeholder string since WebAssembly does not support file storage.
mpp-core/src/wasmJsMain/kotlin/cc/unitmesh/agent/config, mpp-core/src/wasmJsMain/kotlin/cc/unitmesh/agent/logging · high confidence
Add browser localStorage configuration support for WASM
The WASM platform now persists application settings using the browser's localStorage instead of the file system. This change introduces a new \BrowserStorage\ wrapper and a WASM-specific \ConfigManager\ implementation that reads and writes configuration data (including main settings, tool configs, and workspace info) to localStorage keys, enabling configuration management in browser-based environments.
mpp-core/src/wasmJsMain/kotlin/cc/unitmesh/config · high confidence
Add cross-platform process output reading support
The mpp-core module now includes platform-specific implementations for reading process output and managing process lifecycle across Android, JVM, iOS, JS, and WASM targets. On Android and JVM, the system actively reads stdout and stderr streams with timeout handling and process termination capabilities. On iOS, JS, and WASM platforms, native process execution is explicitly unsupported, returning error results instead. This enables consistent process monitoring behavior across supported platforms while gracefully degrading on environments where native process access is unavailable.
(repo-wide) · high confidence
Add custom LLM server examples for ChatGLM and OpenAI proxy
The example/custom\_llm\_server directory now includes two new FastAPI-based server implementations. The chatglm\_sse.py file provides a streaming chat endpoint for ChatGLM models using Server-Sent Events, while openai\_proxy.py acts as a proxy that forwards chat requests to the OpenAI API (api.aios.chat) and streams the response back to the client. These examples demonstrate how to integrate custom or external LLM providers with streaming capabilities.
_example/custom\_llm\server · high confidence
Add custom agent server example with mock API endpoints
The example/custom\_agent directory now includes a FastAPI-based server (server.py) and its documentation (README.md). This server provides mock endpoints for agent interactions, including /api/agent/auto-test and /api/agent/api-market which return plain text responses containing user stories and API specifications, /api/agent/component-list which lists UI components, and /api/agent/ux which serves HTML content. The README provides instructions for setting up a virtual environment and running the server.
_example/custom\agent · high confidence
Add example prompt templates for AI coding assistants
Added a collection of prompt templates in the \example/prompt\ directory to guide AI coding assistants. These include templates for autodev (controller error handling, output formatting, custom DSLs, tasking, and test generation), bloop (code search, file explanation, and function calling), copilot (code completion and search context), jetbrains (code generation, error explanation, and conduct rules), and thoughtworks (code improvement). These examples provide structured inputs for various AI-assisted development scenarios.
example/prompt · high confidence
Add iOS platform support for core agent configuration and logging
The mpp-core module now includes iOS-specific implementations to enable the agent on iOS devices. This adds platform-specific logic for retrieving the current time using Kotlinx DateTime, determining the log directory within the iOS home directory, and initializing console-based logging, allowing the core agent functionality to operate on iOS.
mpp-core/src/iosMain/kotlin/cc/unitmesh/agent/config, mpp-core/src/iosMain/kotlin/cc/unitmesh/agent/logging · high confidence
Add iOS platform support for document parsing and session storage
This change introduces iOS-specific implementations for core Devins capabilities, enabling the application to function on iOS devices. It adds a platform-specific DocumentRegistry that initializes Markdown parsing, a ProjectFileSystem implementation using the iOS Foundation framework for reading, writing, and searching files, and an in-memory SessionStorage for managing chat sessions. These additions allow the multiplatform core to handle file operations and session management natively on iOS.
mpp-core/src/iosMain/kotlin/cc/unitmesh/devins · high confidence
Add iOS platform support to the core agent module
The core agent module now supports iOS, introducing a new platform implementation that provides platform-specific details such as the OS name, version, and home directory. This implementation also integrates with iOS accessibility settings to respect the user's reduced motion preference, ensuring the application behaves appropriately for users with motion sensitivity.
mpp-core/src/iosMain/kotlin/cc/unitmesh/agent · high confidence
Add multi-platform browser agent stubs for Android, iOS, JS, JVM, and WASM
The mpp-core module now includes platform-specific implementations for the web agent's browser interaction and page perception capabilities across Android, iOS, JavaScript, JVM, and WebAssembly targets. These files define the \BrowserActionExecutor\ and \PageStateExtractor\ interfaces and their concrete classes, enabling the agent to execute actions (navigate, click, type, scroll, screenshot) and extract page state (DOM, accessibility tree, URL) on each platform. Currently, these implementations serve as stubs or wrappers around a shared \DriverBasedBrowserActionExecutor\; most platform extractors return empty or null results with \isAvailable\ set to false, while the JVM extractor is marked available but relies on TODO-integrated KCEF/WebEditBridge components. This change establishes the structural foundation for cross-platform browser automation without yet providing full functional behavior on non-JVM platforms.
(repo-wide) · high confidence
Add platform-specific document parser initialization for Android and WASM
The document parsing module now includes platform-specific initialization hooks for Android and WebAssembly (WASM) targets. These new files ensure that the document registry correctly registers available parsers (currently limited to Markdown) during startup on these platforms, providing a consistent initialization flow across the multiplatform codebase.
mpp-core/src/androidMain/kotlin/cc/unitmesh/devins/document, mpp-core/src/wasmJsMain/kotlin/cc/unitmesh/devins/document · high confidence
Add platform-specific time implementation for McpServerLoadingState
Platform-specific implementations for the \McpServerLoadingState\ configuration component have been added for Android and JVM targets. These new files provide the \actual\ function \getCurrentTimeMillis()\, ensuring that the multiplatform configuration module can retrieve the current time using the native system clock on each supported platform.
mpp-core/src/androidMain/kotlin/cc/unitmesh/agent/config, mpp-core/src/jvmMain/kotlin/cc/unitmesh/agent/config · high confidence
Add source code parsing support on the JS platform
Users can now parse source code files (Java, Kotlin, JavaScript, TypeScript, Python, Go, Rust, and C\#) within the JS platform environment. This change introduces a new CodeDocumentParser that extracts code structure (classes, methods, fields) into a hierarchical document model and registers it via the JS-specific DocumentRegistry, enabling features like table-of-contents generation and code querying for these languages on JS.
mpp-core/src/jsMain/kotlin/cc/unitmesh/devins/document · high confidence
Add stubbed WASM filesystem implementation
A new \DefaultFileSystem\ implementation for the WebAssembly (WasmJs) platform has been added to the core filesystem module. This class implements the \ProjectFileSystem\ interface but currently provides only stubbed behavior: file reading, writing, and directory creation operations log a warning and return null/false, while existence checks and file listing return empty results. This allows the WASM target to compile against the filesystem abstraction, though functional file I/O is not yet supported.
mpp-core/src/wasmJsMain/kotlin/cc/unitmesh/devins/filesystem · high confidence
Added Jupyter notebook example for Google Cloud Datalab
A new 'Hello World' Jupyter notebook has been added to the example directory, providing a starting point for users to interact with Google Cloud Datalab. The notebook includes a markdown cell explaining its purpose and a code cell that prints 'Hello!', configured to run in a Python 2 environment.
example · high confidence
Added domain dictionary for AI capabilities
A new domain dictionary file (prompts/domain.csv) has been added to define and map various AI-driven capabilities, such as code translation, sketching, agent execution, and testing, providing a structured reference for these features.
prompts · high confidence
Added project description page for AutoDev Xiuper
A new HTML file (src/description.html) has been added to serve as the project's description page. It outlines AutoDev Xiuper as an AI-native development platform built on Kotlin Multiplatform, highlighting its support for 8+ platforms and 7 SDLC phases, and lists key agents like Coding, Review, and Document agents along with links to the GitHub repository and official website.
src · high confidence
Android CodingAgent now supports file operations via Storage Access Framework
The Android implementation of the CodingAgent's file system tool has been updated to support the Storage Access Framework (SAF). This change allows the agent to read, write, list, and manage files using both standard file paths and content URIs, enabling access to files stored in external storage or provided by other apps through Android's scoped storage permissions.
mpp-core/src/androidMain/kotlin/cc/unitmesh/agent/tool/filesystem · high confidence
Android GitIgnore parsing support added
The Android-specific implementation of the GitIgnore parser is now available, allowing the agent to correctly identify ignored files and directories on Android devices. This change introduces \GitIgnoreParser.android.kt\, which delegates file system operations to a new \AndroidGitIgnoreLoader\ using Java NIO, ensuring consistent behavior with the JVM implementation.
mpp-core/src/androidMain/kotlin/cc/unitmesh/agent/tool/gitignore · high confidence
Android platform logging implementation added
The Android-specific logging module now includes concrete implementations for platform initialization and log directory retrieval. The \initializePlatformLogging\ function relies on Android's native Logcat without requiring additional setup, while \getPlatformLogDirectory\ returns the standard app-specific storage path for log files.
mpp-core/src/androidMain/kotlin/cc/unitmesh/agent/logging · high confidence
Android platform support for code parsing and HTTP fetching
This change introduces Android-specific implementations for core agent tools, enabling code analysis and network operations on Android devices. It adds a regex-based CodeParser (AndroidCodeParserFactory) that extracts code structure and imports for Java, Kotlin, JavaScript, TypeScript, and Python, serving as a simplified alternative to the JVM's TreeSitter parser. Additionally, it provides an Android-optimized HTTP client (HttpClientFactory) using the Ktor CIO engine and an HttpFetcherFactory that wires this client into the agent's tooling, allowing the system to fetch remote resources and parse code on Android.
mpp-core/src/androidMain/kotlin/cc/unitmesh/agent/tool/impl · high confidence
Android-specific NLP keyword extraction implementation
Users on Android devices now have a dedicated NLP tokenizer implementation that extracts keywords from natural language queries using a fallback regex-based approach. This change ensures compatibility by avoiding the JVM-only MyNLP library, which may cause issues on Android, while still supporting both English and Chinese text processing.
mpp-core/src/androidMain/kotlin/cc/unitmesh/agent/chatdb · high confidence
Android-specific file system implementation added
The Android module now includes a concrete \DefaultFileSystem\ implementation that satisfies the \ProjectFileSystem\ interface. This change enables core file operations—such as reading text or binary content, writing files with automatic parent directory creation, checking existence, listing files with pattern matching, searching across directory trees, and creating directories—specifically for the Android platform.
mpp-core/src/androidMain/kotlin/cc/unitmesh/devins/filesystem · high confidence
AutoDev rebrands to Xiuper and introduces multi-platform architecture
The project is rebranded from AutoDev to Xiuper, with the README updated to describe it as an AI-native, multi-agent development platform supporting IntelliJ IDEA, VS Code, CLI, Desktop JVM, Android, iOS, JS/WASM Web, and Server runtimes. The underlying module structure is reorganized into a Kotlin Multiplatform (KMP) composite build, introducing shared modules like mpp-core, mpp-ui, mpp-server, and mpp-idea, alongside standalone packages for VS Code and iOS. Documentation is significantly expanded to detail the 'One Platform' architecture, built-in agents (Document, Coding, Review, ChatDB, Artifact), sub-agent workflows, and global i18n support, while the license is explicitly set to MPL 2.0.
(repo-wide) · high confidence
Automatic chat context compression to reduce token usage
The LLM core now includes a new \ChatCompressionService\ that automatically compresses long conversation histories into concise state snapshots when token usage exceeds a configurable threshold (default 70%). This feature preserves recent messages and key context while significantly reducing the token count sent to the model, helping to stay within model limits and lower costs. The compression logic is driven by structured prompts that generate XML-based state snapshots, and the behavior is controlled via \CompressionConfig\ settings such as the compression threshold, the ratio of recent messages to preserve, and retry policies for failed compressions.
mpp-core/src/commonMain/kotlin/cc/unitmesh/llm/compression · high confidence
DocQL query language engine and execution framework
This change introduces the core DocQL (Document Query Language) engine, enabling users to query document content, structure, and code entities using a JSONPath-like syntax. The implementation includes a lexer and parser to handle operators such as equality, regex matching, and string prefix/suffix checks, along with result types for table of contents, entities, code blocks, and file structures. It provides specialized executors for Markdown files (supporting frontmatter, code blocks, and content chunks) and source code files (supporting class, function, and method queries), unified by a base executor and a factory dispatcher that routes queries based on document format.
mpp-core/src/commonMain/kotlin/cc/unitmesh/devins/document/docql · high confidence
Expanded linter support for infrastructure, security, and multiple languages
The linter module now integrates a broad set of new static analysis tools, allowing users to detect issues across a wider range of file types and domains. New capabilities include infrastructure-as-code validation via Checkov, secret scanning with Gitleaks, and Dockerfile linting via Hadolint. Language-specific support has been added for Python (Pylint, Ruff), Go (golangci-lint), Java (PMD, Detekt), Swift (SwiftLint), SQL (SQLFluff), shell scripts (ShellCheck), and GitHub Actions (actionlint). Additionally, frontend and markup linting is now supported through ESLint, Biome, HTMLHint, and markdownlint, while dotenv-linter covers environment file validation. Each linter is implemented to parse the specific output format of its underlying tool and map findings to the platform's standard issue model.
mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/linter/linters · high confidence
Expose agent capabilities and platform utilities to JavaScript environments
New JS-exported wrappers and platform implementations are added to the core agent module, enabling external JavaScript consumers (such as VS Code extensions or CLI tools) to interact with the system's agents and runtime environment. This includes \JsCodeReviewAgent\, \JsCodingAgent\, \JsDocumentAgent\, and \JsDomainDictAgent\ for executing code reviews, autonomous coding tasks, document queries, and deep research, along with corresponding JS-friendly data classes for results and findings. Additionally, \Platform.js.kt\ and \PlatformExports.kt\ provide JavaScript access to platform detection (OS name, shell, timestamp, home directory) and a \JsCodingAgentRenderer\ interface that allows JS environments to implement custom UI rendering for agent steps, tool calls, and LLM responses.
mpp-core/src/jsMain/kotlin/cc/unitmesh/agent · high confidence
GitIgnore filtering now works on JavaScript/Node.js platforms
The GitIgnore parser now supports JavaScript environments, enabling the agent to correctly identify and filter ignored files when running in Node.js. This implementation adds a platform-specific parser that leverages Node.js file system modules to load .gitignore files and resolve paths, ensuring consistent ignore behavior across different runtime targets.
mpp-core/src/jsMain/kotlin/cc/unitmesh/agent/tool/gitignore · high confidence
Initial Go and Python language support for IDE plugins
This change introduces the first implementation of language-specific context builders and providers for Go (in the Goland plugin) and Python (in the PyCharm plugin). For Go, it adds context builders for files, methods, structs, and variables, along with providers for build systems (go.mod), living documentation, auto-testing, and chat context (Go version). For Python, it adds context builders for files, classes, methods, and variables, along with providers for build systems (requirements.txt, Pipfile, pyproject.toml), living documentation, auto-testing, and chat context (Python SDK). These components enable the core platform to understand and interact with Go and Python codebases within their respective IDEs.
mpp-idea/mpp-idea-lang/goland, mpp-idea/mpp-idea-lang/pycharm · high confidence
Initial JS implementation of artifact bundle packing with JSON fallback
The JS-specific implementation of the artifact bundle packer has been added, providing the core \pack\, \unpack\, and \extractToDirectory\ methods. Currently, packing serializes the bundle to JSON as a fallback since full ZIP support requires external libraries like JSZip or platform-specific APIs. Helper functions are also included to allow browsers to download the bundle as a JSON file or retrieve the constituent files for manual ZIP creation.
mpp-core/src/jsMain/kotlin/cc/unitmesh/agent/artifact · high confidence
Initial Kotlin language support for AutoDev in IntelliJ IDEA
This release adds the first official support for Kotlin in the AutoDev IntelliJ IDEA plugin. The \mpp-idea-lang/kotlin\ module introduces a complete set of language-specific providers that enable the AI agent to understand and modify Kotlin code. This includes context builders for files, classes, methods, and variables; a semantic name collector that extracts filenames and public API names for LLM context; a code modifier for inserting methods and classes; an auto-test service that generates test files in the standard \test/kotlin\ directory; and a living documentation provider for updating KDoc comments. Additionally, Kotlin-specific naming rules are applied to strip technical suffixes (like 'Controller', 'Service', 'Kt') to optimize token usage for the AI.
mpp-idea · high confidence
Initial support for NanoDSL language with syntax highlighting and parsing
Users can now open and edit .nanodsl files with full syntax highlighting, grammar parsing, and file type recognition. This change introduces the NanoDSL language definition, lexer, and parser (including support for components, state, requests, UI elements like VStack/Card, and data binding operators), along with a SketchToolWindow provider for rendering NanoDSL code blocks. Tests have been added to verify parsing of standard UI components and new TravelPlan DSL features.
mpp-idea/mpp-idea-exts/nanodsl-lang · high confidence
Introduce .unit artifact bundle format with Python PEP 723 support
Users can now package generated artifacts into a self-contained, reversible .unit bundle format that preserves generation context for later reloading. This new packaging system includes a PEP 723 parser for Python scripts, allowing inline metadata (such as dependencies and Python version requirements) to be automatically extracted and injected, while Node.js artifacts benefit from automatic dependency detection via require/import statements.
mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/artifact · high confidence
Introduce AI-driven run configuration discovery and execution
Users can now automatically discover project run configurations (such as npm start, gradle bootRun, or cargo run) using an LLM-based analyzer that examines project structure and configuration files. The new RunConfigService manages these configurations, allowing users to execute them directly with streaming output support, while platform-specific process handling ensures cross-platform compatibility for reading process output and managing execution states.
mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/runconfig · high confidence
Introduce AutoDev Xiuper VS Code extension with Kotlin Multiplatform core
The mpp-vscode directory now contains the initial structure for the AutoDev Xiuper VS Code extension, a rewrite leveraging Kotlin Multiplatform (mpp-core) for cross-platform capabilities. This release adds the core extension entry point, a React-based webview chat interface, and CodeLens providers for inline AI actions (Quick Chat, Explain, Optimize, AutoComment, AutoTest, AutoMethod) across TypeScript, JavaScript, Python, Java, Kotlin, Go, and Rust. It integrates the mpp-core bridge for LLM services and auto-completion, includes a DevIns language support provider, and sets up build/publishing infrastructure (including WASM file copying for Tree-sitter and VSIX packaging guidelines).
mpp-vscode · high confidence
Introduce DevIn language support with grammar, parsing, and IDE integration
This change adds the DevIn language definition to the IDE, including a lexer (DevInLexer.flex) and parser (DevInParser.bnf) to recognize the new file type (.devin). It provides core language infrastructure such as file type registration, icon definitions, and a typed handler that triggers code completion when typing specific characters like '@', '/', '$', or ':'. Additionally, it implements a language injector to provide syntax highlighting for code blocks within DevIn files, and introduces a suite of actions for running DevIn scripts, managing context menus, handling database and SonarLint integrations, and processing paste operations via inlay views.
mpp-idea/mpp-idea-exts/devins-lang · high confidence
Introduce DevIns compiler with processor-based template compilation
The DevIns compiler has been implemented in the mpp-core module to transform DevIns AST nodes into executable templates. This change introduces a processor-based architecture where specific components handle distinct node types: the CommandProcessor manages commands including SpecKit and Claude Skill integrations, the AgentProcessor handles agent references, the VariableProcessor resolves variables with built-in support for timestamps and UUIDs, and processors for text segments, code blocks, and front matter manage content rendering. A facade and builder API are provided to simplify compilation with custom variables and options.
mpp-core/src/commonMain/kotlin/cc/unitmesh/devins/compiler/processor · high confidence
Introduce DevIns language lexer and parser foundation
Added the core structural components for the DevIns language processing pipeline, including the token definitions (DevInsTokenType) and token data class (DevInsToken) in the token package, and the Abstract Syntax Tree (AST) node hierarchy (DevInsNode, DevInsFileNode, etc.) in the ast package. This establishes the visitor pattern infrastructure and node types (such as FrontMatter, CodeBlock, Command, and Agent) required to parse and represent DevIns source files, laying the groundwork for the basic lexer and parser implementation.
mpp-core/src/commonMain/kotlin/cc/unitmesh/devins/ast, mpp-core/src/commonMain/kotlin/cc/unitmesh/devins/token · high confidence
Introduce DevIns parser with support for thinking, walkthrough, and devin blocks
The parser module now includes a new \DevInsParser\ and \CodeFence\ implementation that recognizes and parses \\<thinking\>\, \\<!-- walkthrough\_start --\>\, and \\<devin\>\ content blocks in addition to standard code fences. This enables the system to extract structured content from these specific tags, supporting features like LLM reasoning traces and guided walkthroughs within the DevIns format.
mpp-core/src/commonMain/kotlin/cc/unitmesh/devins/parser · high confidence
Introduce KMP Virtual File System with multi-backend support and Compose integration
The xiuper-fs module now provides a Kotlin Multiplatform virtual filesystem abstraction that unifies access to heterogeneous backends—including a SQLDelight-backed database (with v1→v2 schema migration for extended attributes), HTTP-based REST-FS, and MCP resources—under a single POSIX-like API. Users can mount these backends with configurable read-only policies and audit logging, and the new FsRepository adapter enables reactive, StateFlow-based filesystem observation directly within Jetpack Compose UIs.
xiuper-fs · high confidence
Introduce MCP tool configuration, preloading, and loading state management
The agent now supports configuring and preloading Model Context Protocol (MCP) tools in the background to reduce latency when tools are first used. A new configuration model (ToolConfigFile) manages MCP server definitions and explicitly enabled tool names, while built-in tools are always enabled without a UI toggle. The McpToolConfigManager handles concurrent tool discovery and caching, and McpLoadingState provides real-time status (loading, loaded, error, disabled) for each server and the overall set, exposed via callbacks for UI integration.
mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/config · high confidence
Introduce Model Context Protocol (MCP) tool integration for the agent
The agent now supports connecting to external Model Context Protocol (MCP) servers to discover and execute tools. This change adds the core infrastructure for MCP integration, including \McpClientManager\ to handle server connections (via stdio or SSE), \McpConfig\ for defining server settings, and \McpToolAdapter\ to bridge discovered MCP tools into the agent's existing tool execution system. Users can now configure external MCP servers, and the agent will automatically discover available tools from those servers and make them available for use.
mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/mcp · high confidence
Introduce Multi-Database ChatDB Agent with LLM-based Schema Linking
Users can now query across multiple connected databases using a new ChatDB agent that merges schemas, intelligently selects target databases via LLM, and executes queries in parallel. The agent supports conversation continuity, SQL validation with automatic revision, and optional data visualization. Schema linking is enhanced by an LLM-based linker that uses sample data to improve accuracy, alongside a keyword-based fallback and a platform-specific NLP tokenizer for robust keyword extraction.
mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/chatdb · high confidence
Introduce NanoDSL: an AI-agent-driven, indented UI definition language with a structured action system
The xiuper-ui module now provides the core infrastructure for NanoDSL, a Python-style indented syntax designed for AI agents to generate UIs with high semantic density and low token consumption. This change introduces the full specification, including an Abstract Syntax Tree (NanoNode) for layout and content components, a centralized Action System (NanoAction) that restricts interactions to safe, predefined operations like state mutation, navigation, and network fetching, and a platform-agnostic Intermediate Representation (NanoIR) for cross-platform rendering. It also adds a pluggable evaluation framework to validate generated DSL against syntax, structure, and binding criteria, ensuring that agent-generated code remains consistent and error-free.
xiuper-ui · high confidence
Introduce PR review service for GitHub and GitLab
The core module now includes a new PR review service that allows fetching, adding, and replying to pull request comments on GitHub and GitLab. This change adds the \PRReviewService\ interface along with platform-specific implementations (\GitHubPRReviewService\ and \GitLabPRReviewService\) and a factory (\PRReviewServiceFactory\) to instantiate the correct service based on the repository URL. It also introduces a set of shared data models (\PRReviewModels\) to represent PR comments, threads, and review statuses in a platform-agnostic way.
mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/review · high confidence
Introduce Product Feature Tree generation and Document Agent mode
The Document Agent now supports a new FEATURE\_TREE mode alongside the existing DOCUMENT\_QUERY mode. In FEATURE\_TREE mode, the agent acts as a ProductFeatureTreeAgent that analyzes source code to build a hierarchical product feature tree, outputting results in formats like Mermaid mindmaps, PlantUML, or Markdown lists with code references. This is implemented via new model classes (ProductFeature, FeatureLevel, CodeRef) and a renderer, while the agent's system prompt and execution logic are updated to handle this new workflow and tool usage pattern.
mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/document · high confidence
Introduce React-based web UI with landing page and streaming chat
The mpp-web directory now provides a new React application that serves as both the public landing page for www.xuiper.com and the web interface for the AutoDev platform. The landing page features a comprehensive guide to the platform's capabilities and multi-model support, with routing that directs users to the web app at the \#/app hash. The web UI integrates with the mpp-core Kotlin/JS library to provide a streaming chat interface, allowing users to configure LLM providers (such as OpenAI, Anthropic, and Ollama) and interact with AI agents directly in the browser.
mpp-web · high confidence
Introduce React-based webview UI for AutoDev chat and context management
The VS Code extension now uses a new React webview interface for the AutoDev chat experience. This update adds a timeline-based message list with streaming support, a chat input component featuring DevIn syntax highlighting (for commands, agents, and variables), and auto-completion popups. Users can now manage file context via file chips and a file search popup, configure LLM models through a dedicated dialog, and view active plan summaries. The UI is styled to match VS Code's native theme variables.
mpp-vscode/webview · high confidence
Introduce TemplateCompiler for variable substitution and template functions
Added a new TemplateCompiler class in the mpp-core module that processes template strings by replacing variable placeholders (both ${var} and $var formats) using a VariableTable, evaluating simple conditional (\#if...\#end) and loop (\#foreach...\#end) structures, and handling template functions (e.g., {{FUNCTION:args}}). The compiler supports file system access via ProjectFileSystem for reading file content and includes stub implementations for various agent and utility functions, enabling users to compile DevIns outputs into executable templates with cross-platform regex compatibility.
mpp-core/src/commonMain/kotlin/cc/unitmesh/devins/compiler/template · high confidence
Introduce Text2SQL database connection and SQL validation infrastructure
The database agent module now includes a new \ExposedDatabaseConnection\ implementation for managing database connections and executing queries, along with a \SqlValidator\ class that leverages JSQLParser to parse, validate, and assess the safety of generated SQL statements before execution. An example file (\DatabaseConnectionExample.kt\) demonstrates how to configure and use these components for operations like schema retrieval and query execution.
mpp-core/src/jvmMain/kotlin/cc/unitmesh/agent/database · high confidence
Introduce WASM-JS code parsing via TreeSitter
A new WASM-JS implementation of the code parser is now available, enabling code analysis in browser environments. This change adds the \WasmJsCodeParser\ which leverages the TreeSitter WASM runtime to parse source code and extract syntax nodes and relationships. The \CodeGraphFactory\ in this module now provides this WASM-based parser as the actual implementation for the \CodeParser\ interface, allowing the code graph engine to operate on JavaScript/WASM targets.
mpp-codegraph/src/wasmJsMain · high confidence
Introduce WebAgent core models and execution interfaces for E2E testing
The \mpp-core\ module now includes the foundational components for the WebAgent E2E testing system. This adds data models for test scenarios, steps, and page states (including Set-of-Mark element tagging), along with interfaces for platform-specific browser interaction (\BrowserActionExecutor\, \PageStateExtractor\) and a self-healing locator that uses algorithmic and LLM-based strategies to recover from selector failures. A \TestActionPlanner\ is also introduced to orchestrate test execution by planning actions via predefined steps or LLM inference, supporting both JSON and DSL formats for scenario generation.
mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/webagent · high confidence
Introduce Workspace system for project management and file completion
The platform now includes a Workspace abstraction that manages project resources, file system access, and code completion capabilities. Users can create and manage workspaces with associated root paths, which automatically initialize file system and completion managers. The system tracks workspace state (initialized, loading, error) via reactive flows and supports operations like refreshing configurations and closing workspaces. Additionally, Git integration data structures (commit info, diff info, file status) are now available within the workspace context for tracking changes.
mpp-core/src/commonMain/kotlin/cc/unitmesh/devins/workspace · high confidence
Introduce core data models and state management for agent plans
Added the foundational classes for the agent's planning system, including AgentPlan, PlanTask, and PlanStep, which organize work into hierarchical tasks and steps with status tracking (TODO, IN\_PROGRESS, COMPLETED, FAILED, BLOCKED) and progress calculation. The diff introduces a reactive PlanStateService using Kotlinx StateFlow to manage plan lifecycle events (creation, updates, step completion) and notify listeners, ensuring UI components can react to state changes. Additionally, a MarkdownPlanParser enables parsing and formatting plans from markdown text, supporting code file links within steps, while PlanSummaryData provides lightweight summaries for UI display.
mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/plan · high confidence
Introduce cross-platform GitIgnore parsing and filtering
Added a new GitIgnore tool module that provides a cross-platform parser and filter for .gitignore rules. This includes a pattern matcher supporting standard gitignore syntax (wildcards, negation, directory-only patterns) and a base parser that loads .gitignore files and .git/info/exclude from the file system using platform-specific loaders, enabling the agent to correctly determine which files should be ignored during project analysis.
mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/tool/gitignore · high confidence
Introduce cross-platform ProjectFileSystem abstraction with binary and write support
A new \ProjectFileSystem\ interface has been added to provide a unified, cross-platform abstraction for project file operations. This change introduces support for reading binary files via \readFileAsBytes\ (previously only text was supported) and adds the ability to write files through a new \writeFile\ method. The implementation leverages Kotlin's \expect/actual\ mechanism to ensure compatibility across different platforms, while also including an \EmptyFileSystem\ for testing scenarios and a \DefaultFileSystem\ for standard operations.
mpp-core/src/commonMain/kotlin/cc/unitmesh/devins/filesystem · high confidence
Introduce cross-platform shell execution with live streaming and ANSI cleanup
Users can now execute shell commands via a new cross-platform shell executor that supports live terminal output streaming on platforms with PTY support, while falling back to buffered output elsewhere. The system includes an ANSI stripper to clean color codes and escape sequences from terminal output for readable display, and a session manager to track, cancel, and kill running shell processes. Command validation logic is centralized to block dangerous operations, and the executor attempts to load the user's login shell environment by default to ensure tools like Homebrew-installed binaries resolve correctly.
mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/tool/shell · high confidence
Introduce modular scoring and reranking architecture
The search and retrieval system now uses a modular scoring architecture with specialized components. A new \ScoringModel\ interface standardizes how text segments are evaluated. The system includes a \BM25Scorer\ for term-frequency relevance, a \TypeScorer\ to prioritize code entities (classes, functions) over documentation, and a \NameMatchScorer\ for exact and partial name matching. These are combined in a \CompositeScorer\ with configurable weights. For multi-source retrieval, an \RRFScorer\ implements Reciprocal Rank Fusion to combine rankings. A \DocumentReranker\ orchestrates these strategies, supporting both single-source and multi-source reranking with configurable thresholds. Additionally, a \HeuristicScoringModel\ provides a simple type-based scoring fallback, and a \KeywordExpander\ enables adaptive search by expanding queries into primary, secondary, and tertiary keyword levels to adjust result counts. Rich metadata extraction (\DocumentRichMetadata\) and LLM-based reranking (\LLMMetadataReranker\) are also introduced for intelligent, context-aware result ranking.
mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/scoring · high confidence
Introduce mpp-server as a remote AI coding agent with SSE streaming and session management
This change introduces the mpp-server module, a Ktor-based HTTP server that exposes remote AI coding agent capabilities to clients (such as Android apps). It provides REST endpoints for project management and synchronous agent execution, alongside a Server-Sent Events (SSE) streaming endpoint for real-time agent progress. The server supports cloning remote Git repositories on demand, handles LLM configuration via environment variables or local config files, and includes a basic session management system with user authentication (login, register, token validation). Deployment is supported via Docker and Render, with a health check endpoint for monitoring.
mpp-server · high confidence
Introduce mpp-ui module with multiplatform UI and Node.js REPL support
The mpp-ui module is added as the new multiplatform UI layer for the application, built on Compose Multiplatform 1.8.0 and supporting JVM (Desktop), Android, JS (Web), and Node.js (CLI) targets. It introduces a new Markdown rendering system via MarkdownSketchRenderer, a cross-platform file chooser, and a Node.js REPL environment that bundles a specific Node runtime and modules for CLI execution. The module also includes a configuration example for managing multiple LLM providers and implements internationalization (i18n) with support for English and Chinese across all platforms.
mpp-ui · high confidence
Introduce mpp-viewer core API for universal content display
Added the mpp-viewer module, which provides a platform-agnostic API for displaying various content types including code, markdown, images, PDFs, video, and audio. This change introduces the core interfaces and data structures required for the viewer, specifically the ViewerHost interface for hosting viewer components, the ViewerRequest data class for specifying content and display options, the ViewerType enumeration for supported content categories, and a LanguageDetector utility for identifying programming languages from file paths to enable syntax highlighting.
mpp-viewer · high confidence
Introduce mpp-viewer-web module for cross-platform web viewing and editing
The new mpp-viewer-web module provides a WebView-based implementation of the viewer API for AutoDev, enabling cross-platform support (JVM, Android, iOS) via compose-webview-multiplatform. It includes a WebViewerHost and ViewerWebView composable for displaying content with offline-capable HTML and Monaco Editor integration for code syntax highlighting. Additionally, it introduces a WebEditBridge and WebEditView for web page browsing and DOM selection, featuring automation support, accessibility tree extraction, and D2Snap (downsampled DOM snapshot) compression for LLM agents. The module also includes lightweight fallback icons to replace material-icons-extended dependencies.
mpp-viewer-web · high confidence
Introduce multi-language linter framework with AI-powered detection
The linter module now supports a broad range of programming languages (including Kotlin, Java, JavaScript, TypeScript, Python, Rust, Go, Ruby, PHP, Shell, Markdown, YAML, Docker, SQL, Swift, HTML, and CSS) by introducing a \LanguageDetector\ and a \LintDetector\ that automatically identifies installed tools such as detekt, pmd, biome, oxlint, ruff, pylint, flake8, shellcheck, golangci-lint, clippy, rubocop, phpstan, pmd, swiftlint, markdownlint, yamllint, hadolint, and sqlfluff. The system features a new \LinterRegistry\ for managing linter instances and a redesigned \LinterSummary\ that presents results grouped by severity (errors, warnings, info) with up to 10 top issues per file. Additionally, an \AILinter\ implementation allows the system to dynamically generate linter commands and parse their output using an LLM service, providing a flexible fallback or primary method for linting that adapts to various linter output formats without hardcoding parsers.
mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/linter · high confidence
Introduce multimodal image attachment support with file context and event-driven editor callbacks
The editor now supports submitting content with attached file context and multimodal image analysis. A new \FileContext\ data class tracks file metadata (name, path, relative path, directory status) to provide context during submissions. The \EditorCallbacks\ interface has been extended with \onSubmitWithMultimodal\, which accepts text, file context, and image analysis results; by default, it appends the vision model's analysis to the user's text before triggering the standard submission. Additionally, \EditorEvent\ introduces a sealed class hierarchy for editor events (Submit, TextChanged, CursorMoved, SelectionChanged, FocusGained, FocusLost), enabling event-driven handling of editor state changes alongside the callback-based approach.
mpp-core/src/commonMain/kotlin/cc/unitmesh/devins/editor · high confidence
Introduce native iOS application with Swift-based MCP integration
The mpp-ios directory now contains a complete, buildable iOS application (AutoDevApp) that serves as the native host for the Kotlin Multiplatform UI. The app uses SwiftUI to wrap the Compose Multiplatform interface via a \UIViewControllerRepresentable\ bridge, allowing users to run the shared UI on iOS devices. It introduces a Swift-native \MCPManager\ that handles connections to Model Context Protocol servers (supporting both HTTP and simulator-only Stdio transports) and exposes discovered tools to the application. The project is configured with CocoaPods to link the \AutoDevUI\ framework and includes automated build scripts (\build-ios-app.sh\) to compile the Kotlin frameworks, resolve dependencies, and generate the \.app\ bundle.
mpp-ios · high confidence
Introduce persistent chat session history and metadata support
Added a new chat history management system that automatically persists chat sessions to disk (chat-sessions.json) and restores them on startup, ensuring conversation continuity across application restarts. The system includes logic to auto-generate session titles from the first user or assistant message if none are provided, and supports reactive UI updates for session lists. Additionally, it introduces a MessageMetadata structure to preserve detailed timeline item information (such as tool calls, terminal output, and DocQL stats) within messages, enabling accurate reconstruction of complex agent interactions in the history view.
mpp-core/src/commonMain/kotlin/cc/unitmesh/devins/llm · high confidence
Introduce pluggable DevInsCompilerService for switchable compiler cores
The compiler core is now abstracted behind the new DevInsCompilerService interface, allowing users to switch between the default cross-platform implementation (DefaultDevInsCompilerService, based on a custom AST parser) and an IDE-specific implementation (IdeaDevInsCompilerService, based on PSI) depending on the environment. This change enables IDE-specific features such as symbol resolution, refactoring, and code structure analysis when running within the IntelliJ IDEA plugin, while maintaining a lightweight, cross-platform compatible compiler for CLI, Desktop, and WASM environments.
mpp-core/src/commonMain/kotlin/cc/unitmesh/devins/compiler/service · high confidence
Introduce structured document parsing and multi-format support
The document module now supports parsing and querying a wider range of file types, including Markdown, PDF, DOCX, PPT, PPTX, and source code files. This change introduces a new \DocumentParserFactory\ and \DocumentRegistry\ to manage format-specific parsers, enabling features like hierarchical Table of Contents (TOC) generation, entity extraction (classes, functions, terms), and DocQL-based content queries. Users can now navigate documents via a tree structure and search for specific sections or entities across indexed files.
mpp-core/src/commonMain/kotlin/cc/unitmesh/devins/document · high confidence
Introduce unified multiplatform logging system
The mpp-core module now includes a new, unified logging infrastructure built on kotlin-logging. This change adds a centralized AutoDevLogger singleton, a configurable LoggingConfig data class (supporting file and console output with rotation), and a LoggingInitializer that handles platform-specific setup for JVM, JS, and Android. Users gain consistent, structured logging across all supported platforms with configurable log levels and output destinations.
mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/logging · high confidence
Introduces ACP capabilities model for client and agent initialization
The library now includes a structured capabilities model in the \com.agentclientprotocol.model\ package, defining how clients and agents advertise supported features during initialization. This change adds serializable data classes for \ClientCapabilities\ (covering file system, terminal, and metadata), \AgentCapabilities\ (including prompt, MCP, and session support), and specific capability groups for file system access, prompt content types (audio, image, embedded context), MCP transports (HTTP, SSE), and session management (fork, list, resume). Unstable APIs are marked for session-related capabilities that are not yet part of the official specification, allowing early adoption while signaling potential changes.
commonMain · high confidence
Introduces JVM-only ACP agent client and server infrastructure
This change adds the core JVM-side components for the Agent Client Protocol (ACP) integration, enabling the application to act as both an ACP client (connecting to external agents like Claude or Gemini) and an ACP server (exposing internal capabilities to external editors). The new \AcpAgentProcessManager\ handles the lifecycle of external agent processes, including reuse, health monitoring, and graceful shutdown. \AcpClient\ and \AcpAgentSession\ manage the bidirectional communication, supporting file system and terminal capabilities, MCP server loading from configuration, and automatic reconnection. Additionally, \AcpAgentServer\ and \AcpRenderer\ allow the internal coding agent to stream updates back to ACP-compatible clients, while \AcpEventCapture\ provides a diagnostic tool for recording raw protocol events.
mpp-core/src/jvmMain/kotlin/cc/unitmesh/agent/acp · high confidence
Introduces a dual-theme (light/dark) color system for the UI
The application now supports light and dark mode theming through a new design system. This change adds a comprehensive color palette (including Indigo, Cyan, Neutral, Green, Amber, Red, and Blue scales) and defines specific color tokens for primary, accent, text, surface, border, and semantic states. The \ColorSystem.kt\ file in the common module establishes these themes, while \ColorSystemExports.kt\ in the JS module exposes the color scales and theme objects to the JavaScript environment for consumption by the frontend.
mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/ui, mpp-core/src/jsMain/kotlin/cc/unitmesh/agent/ui · high confidence
Introduces a new, structured completion system with context-aware providers and fuzzy file search
The completion engine has been refactored to use a new \CompletionContext\ and \CompletionItem\ model, enabling more precise, context-aware suggestions. A new \CompletionManager\ orchestrates multiple providers, including support for agent triggers (@), commands (/), variables ($), and file paths (:). File path completions now leverage a \RecursiveFileSearch\ implementation that supports fuzzy matching, wildcard patterns, and result caching for improved performance. Users will experience smarter, faster, and more relevant auto-completion across different input types.
mpp-core/src/commonMain/kotlin/cc/unitmesh/devins/completion · high confidence
Introduces core agent architecture with SubAgent management and platform availability checks
This change establishes the foundational agent execution model by introducing the \Agent\ base class, which implements the \ExecutableTool\ interface to allow agents to be invoked as tools. It adds \MainAgent\ for managing tool registration and \SubAgent\ for handling specific sub-tasks, including a new \handleQuestion\ method for inter-agent communication. A \SubAgentManager\ is introduced to coordinate these agents, featuring automatic detection and delegation of long content to an analysis agent, as well as platform-specific availability checks that prevent registration of unsupported agents. The \AgentExecutor\ interface defines the contract for the main execution loop, including activity callbacks and cancellation support.
mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/core · high confidence
Introduces core agent model definitions for configuration, execution context, and activity tracking
This change adds the foundational data models for the agent system in the core module. It introduces \AgentDefinition\ to support declarative agent configuration, including prompt settings, LLM model configuration, run parameters, and tool constraints. It also defines \AgentContext\ to manage execution state (agent ID, session, inputs) and \AgentResult\/\AgentStep\ to represent execution outcomes and detailed step-by-step history. Additionally, \AgentActivity\ is added as a sealed class to report real-time agent events such as tool calls, thoughts, progress, and errors.
mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/model · high confidence
Introduces core code graph models and parser interface for multi-language analysis
This change adds the foundational data models and parsing interface for the code graph feature in the common module. It defines the \CodeGraph\, \CodeNode\, and \CodeRelationship\ structures to represent code elements and their connections, including support for constructor entities and various relationship types like inheritance and dependencies. It also introduces \ImportInfo\ and \FileImports\ models to capture detailed import statement data across multiple languages (Java, Kotlin, Python, JavaScript, Go, Rust, etc.). Additionally, it provides the \CodeParser\ interface and \CodeGraphFactory\ to enable platform-specific AST-based parsing implementations.
mpp-codegraph/src/commonMain · high confidence
Introduces core session management data models
The \Session.kt\ file in the \mpp-core\ module now defines the foundational data structures for session management, including the \Session\ entity, its lifecycle statuses (\PENDING\, \RUNNING\, \COMPLETED\, etc.), and associated metadata. It also introduces models for session participants (\SessionParticipant\), event tracking (\SessionEventEnvelope\), and state snapshots (\SessionState\) to support features like disconnection reconnection. Additionally, basic authentication models (\User\, \LoginRequest\, \LoginResponse\) are included to handle simple user login flows within this module.
mpp-core/src/commonMain/kotlin/cc/unitmesh/session · high confidence
Introduces cross-platform Git operations abstraction with detailed error handling
The platform layer now exposes a new \GitOperations\ interface (using Kotlin Multiplatform's \expect\ class) that defines core Git capabilities such as cloning repositories, retrieving modified files, viewing diffs, and checking commit history across JVM, Android, and JS/Wasm targets. To improve user experience during failures, a new \GitCloneException\ class has been added, which categorizes errors into specific types (initialization, CORS, network, or clone failure) so the UI can provide context-specific feedback.
mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/platform · high confidence
Introduces multiple new completion providers for agents, commands, files, and variables
The completion system now includes several new providers: AgentCompletionProvider offers suggestions for agent actions like clarify, code-review, test-gen, and refactor via @ mentions; BuiltinCommandCompletionProvider provides completions for system commands such as /help, /clear, /exit, /config, /model, and /init; FilePathCompletionProvider enables file path completion with static common file suggestions and dynamic recursive fuzzy search with caching; SpecKitCommandCompletionProvider dynamically loads and suggests SpecKit commands from the project filesystem; ToolBasedCommandCompletionProvider suggests tools from the global tool registry, using specific separators like ':' for file-related tools; and VariableCompletionProvider suggests variables extracted from FrontMatter and predefined ones like input, output, context, selection, and clipboard.
mpp-core/src/commonMain/kotlin/cc/unitmesh/devins/completion/providers · high confidence
Introduces new agent modes and artifact generation capabilities
The agent system now supports additional modes including Artifact, WebEdit, Knowledge, and ChatDB, alongside the existing Coding and Code Review agents. The new Artifact mode allows the AI to generate self-contained, executable content such as HTML, React, Node.js, Python, SVG, and Mermaid diagrams, which are displayed in a separate UI window. The WebEdit mode enables browsing and interacting with web pages, while Knowledge mode provides AI-native document reading and ChatDB supports text-to-SQL database queries. These new capabilities are defined in the AgentType enum and implemented via dedicated agent classes and prompt templates.
mpp-core/src/commonMain/kotlin/cc/unitmesh/agent · high confidence
Introduces unified cross-platform database connection interface
A new \DatabaseConnection\ interface has been added to the core agent module, providing a unified, cross-platform abstraction for database interactions. This interface standardizes how the system executes SQL queries and updates, retrieves schema information, and performs dry-run validations before execution. It also includes helper methods for fetching sample rows and distinct values, which support improved schema linking and context building for AI agents. This change establishes the foundational infrastructure for the new Text2SQL database provider, allowing platform-specific implementations (JVM, IDEA, WASM) to plug in their own database drivers while maintaining a consistent API for the agent logic.
mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/database · high confidence
Introduction of a cross-platform color system interface
A new \ColorSystem\ interface has been added to the theme module, defining a structured abstraction for colors across the application. This interface organizes colors into specific scales—Void (backgrounds/surfaces), Energy (primary/AI colors), Signal (status indicators), Text, and Syntax highlighting—and includes legacy aliases (such as indigo, cyan, and neutral) to ensure backward compatibility with existing color references. This change establishes the foundational contract for platform-specific UI implementations to adhere to a unified design system.
mpp-core/src/commonMain/kotlin/cc/unitmesh/devins/theme · high confidence
JVM Git operations implementation added
A new JVM-specific implementation of the GitOperations interface has been added, enabling core Git functionalities such as cloning repositories, retrieving modified files, fetching recent commits, and analyzing diffs. This change introduces the concrete logic required for Git interactions on the JVM platform, supporting the broader multi-platform agent architecture.
mpp-core/src/jvmMain/kotlin/cc/unitmesh/agent/platform · high confidence
JVM code parsing implementation with multi-language support
The JVM-specific code graph implementation is now available, providing the actual factory and parser logic for the JVM platform. The JvmCodeParser leverages TreeSitter to parse source code and extract import statements for Java, Kotlin, Python, JavaScript, TypeScript, Rust, and Go. This change completes the multiplatform setup by wiring the JVM-specific parser into the CodeGraphFactory, enabling code analysis capabilities on JVM-based environments.
mpp-codegraph/src/jvmMain · high confidence
JVM file system implementation with binary read, write, and gitignore-aware search
The JVM platform now has a concrete \DefaultFileSystem\ implementation that supports reading files as text or binary bytes, writing text files (creating parent directories as needed), and searching for files using glob patterns. The search functionality respects \.gitignore\ rules via a \GitIgnoreParser\, excludes critical directories like \.git\ and \build\, and handles multi-extension globs and recursive \\\\ patterns.
mpp-core/src/jvmMain/kotlin/cc/unitmesh/devins/filesystem · high confidence
JVM platform detection and system integration implementation
The JVM-specific platform implementation now provides detailed system information, including OS name, version, architecture, and user home directory. It introduces methods to retrieve the default shell (cmd.exe on Windows, zsh on macOS, bash otherwise) and current timestamp. Additionally, it implements logic to detect the user's reduced motion preference by checking macOS system defaults, Windows environment variables, and Linux GTK settings, ensuring accessibility preferences are respected on desktop environments.
mpp-core/src/jvmMain/kotlin/cc/unitmesh/agent · high confidence
JVM-specific GitIgnore parsing implementation added
A new JVM-specific implementation of the GitIgnore parser has been added to the agent tooling. This change introduces \GitIgnoreParser.jvm.kt\ and \JvmGitIgnoreLoader\, which utilize Java NIO to load \.gitignore\ files, list directories, and resolve relative paths on the JVM platform. This provides the concrete platform logic required for the cross-platform GitIgnore filtering feature within the \mpp-core\ module.
mpp-core/src/jvmMain/kotlin/cc/unitmesh/agent/tool/gitignore · high confidence
Java language support added to the IntelliJ plugin
This change introduces comprehensive Java language support for the plugin within the IntelliJ platform. It adds a suite of context builders to extract structured information from Java code, including details about classes, methods, variables, and files. A code modifier is included to handle the insertion of test code into Java source files, and a dictionary provider is implemented to collect semantic names (filenames, class names, method names) for LLM context generation, specifically stripping technical suffixes like 'Controller' or 'Service'. Additionally, the update includes utilities for detecting Java language levels, parsing MVC context from imports, and integrating with the Gradle build system for task collection and library data.
mpp-idea/mpp-idea-lang/java · high confidence
JavaScript language support added to the IDE plugin
This change introduces comprehensive support for JavaScript and TypeScript projects within the IDE plugin. It adds a new \JsDependenciesSnapshot\ class to analyze \package.json\ files, detect frameworks (React, Vue, Angular, etc.), and identify build tools (Vite, Webpack, etc.). This context is used by \JavaScriptContextProvider\ to enrich AI chat interactions with project-specific details. Additionally, it implements an 'AutoPage' feature for React applications, allowing the AI to generate pages by analyzing project structure (views, pages, components) and routing configurations. The update also includes providers for living documentation, build systems, and UI component views specifically tailored for JavaScript/TypeScript files.
mpp-idea/mpp-idea-lang/javascript · high confidence
JavaScript platform now supports NanoDSL validation and source-only parsing
The NanoDSL parser on JavaScript platforms now includes a concrete validation implementation (NanoDSLValidator) that performs basic syntax checks, such as verifying balanced parentheses and braces, enforcing 4-space indentation, and detecting known versus unknown components. Unlike the JVM platform which generates a full Abstract Syntax Tree (AST), the JavaScript implementation returns a source-only Intermediate Representation (IR) after validation passes, enabling UI rendering integration and validation/retry mechanisms in browser-based environments.
mpp-core/src/jsMain/kotlin/cc/unitmesh/agent/parser · high confidence
JavaScript platform-specific HTTP and code parsing implementations
The core library now includes platform-specific implementations for the JavaScript environment to support web fetching and code parsing. This adds a JavaScript-specific HTTP client factory using Ktor's JS engine, a dedicated Node.js HTTP fetcher that leverages the native Node.js fetch API (bypassing Ktor limitations in Node.js 18+), and a JavaScript code parser factory. These changes enable the agent to perform web requests and parse JavaScript code natively within JS/Node.js runtimes.
mpp-core/src/jsMain/kotlin/cc/unitmesh/agent/tool/impl · high confidence
New AI-driven database actions and schema integration in IntelliJ IDEA
The database extension now includes several new AI-powered actions: AutoSql generates SQL scripts from natural language requirements by clarifying table context and designing queries in the background; GenerateEntity, GenerateFunction, and GenerateUnittest create code artifacts from selected SQL text, specifically for Oracle dialects with a check to prevent NoClassDefFoundErrors when the Oracle plugin is missing. Additionally, the extension integrates database schema information into the AI chat context, provides tools for agents to query schema and execute SQL, and adds a service to run SQL files directly within the IDE.
mpp-idea/mpp-idea-exts/ext-database · high confidence
New AI-powered Git and Terminal assistance actions
The Git extension now includes several new AI-driven actions: Code Review and Prepush Review analyze code changes to generate Mermaid structure diagrams and prompt the AI for feedback; Commit Message Suggestion and Release Note Suggestion use AI to generate commit messages and changelogs based on diffs and commit history; and a new Terminal extension adds a Shell Command Suggestion action that suggests commands via AI. Additionally, VCS tools are exposed via MCP for external tool integration, and Git-specific providers enable variable resolution and action location editing within the IDE.
mpp-idea/mpp-idea-exts/ext-git, mpp-idea/mpp-idea-exts/ext-terminal, mpp-idea/mpp-idea-lang/rust · high confidence
New ConversationManager for multi-turn agent dialogues with automatic context compression
A new ConversationManager class has been introduced in the agent conversation module to handle multi-turn interactions between the user and the LLM. This component maintains conversation history, manages system and user prompts, and supports streaming responses. A key feature is automatic context compression, which triggers when the token count approaches the model's limit, helping to manage context window constraints during long conversations. The manager also provides utilities for retrieving recent history, updating system prompts, and monitoring conversation statistics.
mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/conversation · high confidence
New E2E Test DSL with LLM-powered generation and CSS selector support
The xiuper-e2e module now includes a new domain-specific language (DSL) for defining end-to-end tests, featuring a parser, a generator, and an integration layer with the LLM service. Users can now write human-readable test scenarios using a structured syntax that supports actions like click, type, and assert, with support for CSS selectors to identify elements. The E2EDslIntegration class allows generating test scenarios from natural language descriptions via the LLM, parsing DSL strings into executable test scenarios, and generating DSL from existing scenario objects. Example DSL files and comprehensive tests for the parser and generator are included to validate the new functionality.
xiuper-e2e · high confidence
New HTTP tooling with platform-specific fetchers and URL parsing
The HTTP agent tool implementation has been reorganized into a dedicated package, introducing a platform-agnostic HTTP fetching capability. Users can now fetch web content via a new \KtorHttpFetcher\ that automatically selects the optimal engine for the current platform (CIO for JVM, fetch API for JS, and native engines for Native targets). The tool includes a \UrlParser\ that extracts and validates HTTP/HTTPS URLs from prompts, normalizes GitHub blob links to raw content URLs, and rejects unsupported protocols. A factory pattern (\HttpClientFactory\ and \HttpFetcherFactory\) ensures each platform receives its appropriate HTTP client configuration.
mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/tool/impl/http · high confidence
New JavaScript implementations for SQL validation and SubAgent exports
This change introduces a JavaScript-specific implementation of the SQL validator (SqlValidator.js.kt) that performs basic syntax validation and table extraction using regex, serving as a lighter alternative to the full JSqlParser available on JVM platforms. Additionally, it adds a new SubAgentExports.kt file that exposes JavaScript-friendly wrappers for the ErrorRecoveryAgent, AnalysisAgent, NanoDSLAgent, and ChartAgent, allowing these agents to be invoked from JavaScript environments with improved interoperability by returning ToolResult.AgentResult directly.
mpp-core/src/jsMain/kotlin/cc/unitmesh/agent/subagent · high confidence
New Markdown code block parser utility
A new MarkdownCode utility class has been added to the mpp-core common module, providing a parse method that extracts code content from Markdown fenced code blocks. This utility identifies the programming language, extracts the code text, handles incomplete blocks, and trims surrounding whitespace, making it available for use across the multiplatform core.
mpp-core/src/commonMain/kotlin/cc/unitmesh/utils · high confidence
New SubAgents for analysis, visualization, and domain modeling
The subagent module now includes several new specialized agents: AnalysisAgent for summarizing and extracting insights from various content types; ChartAgent and PlotDSLAgent for generating chart code (with PlotDSL restricted to JVM Desktop and Android where Lets-Plot Compose is supported); CodebaseInvestigatorAgent for analyzing project structure and dependencies; DomainDictAgent for generating domain dictionaries from codebase analysis; ErrorRecoveryAgent for analyzing errors and suggesting fixes with cross-platform Git support; and NanoDSLAgent for generating UI code with validation, retry logic, and optional image generation. ImageSrcExtract provides utilities for extracting image prompts and handling fake LLM-generated URLs.
mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/subagent · high confidence
New agent tools and cross-platform file system abstraction
The agent now includes several new capabilities: a DocQL tool for querying documents and code structure with advanced reranking, a CodebaseInsights tool for analyzing Git changes and code structure, an AskAgent tool for inter-agent communication, an EditFile tool for precise text replacements, and Glob/Grep tools for file searching with .gitignore support. These tools rely on a new cross-platform ToolFileSystem abstraction built on kotlinx-io, replacing previous file system implementations.
mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/tool/impl · high confidence
New artifact execution framework with .unit bundle support
The artifact module now includes a complete execution framework for Node.js, Python, and Web artifacts. Users can package artifacts into .unit bundles (ZIP files) using ArtifactBundlePacker, which includes a security check to prevent zip-slip attacks during extraction. The new ArtifactExecutorFactory routes execution to type-specific executors: NodeJsArtifactExecutor handles npm installs and Node.js execution with recovery logic for malformed package.json files; PythonArtifactExecutor supports PEP 723 inline metadata and installs dependencies via uv (preferred) or pip fallback; WebArtifactExecutor serves HTML/SVG files via a local HTTP server. Long-running processes (like Express.js servers) are managed by ProcessManager, allowing start/stop controls. The legacy ArtifactExecutor is deprecated in favor of the new factory-based approach.
mpp-core/src/jvmMain/kotlin/cc/unitmesh/agent/artifact · high confidence
New diff and file-change tracking utilities in the agent core
The \mpp-core\ module now includes a new \agent.diff\ package containing models and utilities for handling code differences and tracking file modifications. \DiffModels.kt\ introduces data classes (\FileDiff\, \DiffHunk\, \DiffLine\) and a \DiffParser\ object capable of parsing both Git-specific and standard Unified Diff formats. \DiffUtils.kt\ provides a line-based diff algorithm (using LCS) to calculate statistics and generate unified diff strings. \FileChange.kt\ defines a serializable \FileChange\ model with helper methods for computing line and character differences, while \FileChangeTracker.kt\ offers a singleton to record, merge, and observe file changes via \StateFlow\, enabling tools to track session-level modifications.
mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/diff · high confidence
New diff context compression and code extraction utilities
The VCS module now includes a new set of utilities to optimize how code changes are processed for AI analysis. \ChangedCodeExtractor\ parses git diff patches to isolate specific code hunks with configurable context lines, reducing the amount of data sent to the model. \DiffContextCompressor\ prioritizes files based on their type (e.g., source code vs. documentation) and truncates diffs to fit within token limits, ensuring critical changes are preserved. \DiffFormatter\ cleans up raw diff output by removing metadata and standardizing file operation markers, while \FilePriority\ defines the rules for this prioritization. Together, these components streamline the input provided to code review agents.
mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/vcs · high confidence
New domain dictionary generation and code clustering capabilities
The indexer now includes a new domain dictionary generator that creates a business-oriented dictionary from the codebase by extracting semantic names and using an LLM to map them to code identifiers. This generator uses a new DomainDictService to collect semantic names from file paths, applying camel-case splitting and suffix removal to filter technical noise. To improve context understanding, the indexer introduces a clustering system with multiple strategies: an import-dependency clusterer that builds a dependency graph from AST-based import parsing, a code-graph clusterer leveraging TreeSitter for accurate structure analysis, and a placeholder for git co-change clustering. These components work together to group related files into modules, providing richer context for the LLM prompts used in code translation and analysis.
mpp-core/src/commonMain/kotlin/cc/unitmesh/indexer · high confidence
New multi-format document parsing capabilities
The document module now supports parsing a wider range of file types. Source code files (Java, Kotlin, Python, JavaScript, TypeScript, Go, Rust, C\#) are parsed into hierarchical structures using mpp-codegraph. PDF documents are processed with Apache PDFBox, offering both page-based and paragraph-based text extraction. Microsoft Office formats (DOCX, PPT) and plain text are handled via Apache Tika, while HTML files are parsed using Jsoup to extract content and headings. A new DocumentRegistry automatically registers these parsers on the JVM platform.
mpp-core/src/jvmMain/kotlin/cc/unitmesh/devins/document · high confidence
New parser components for DevIn blocks and tool calls
The parser module introduces new classes to handle LLM response parsing: DevinBlockParser extracts and processes \<devin\> blocks, ToolCallParser identifies tool calls within those blocks (supporting both simple line-based and JSON parameters), EscapeSequenceProcessor handles string escaping, and NanoDSLValidator provides cross-platform validation for NanoDSL source code.
mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/parser · high confidence
New tool schema and formatting infrastructure for agent interactions
The agent's tool handling now uses a dedicated schema package containing a declarative \ToolSchema\ interface and builder for generating JSON schemas compatible with OpenAI function calling and MCP formats. A new \AgentToolFormatter\ provides consistent, enhanced tool list formatting for AI contexts, including automatic JSON schema injection and DevIns-style usage examples. Tool execution results are now formatted via \ToolResultFormatter\, which explicitly supports and structures output for parallel tool executions, improving clarity for the LLM.
mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/tool/schema · high confidence
Platform-specific configuration storage implementations for Android, iOS, and JS
The application now uses platform-specific implementations to manage configuration files (config.yaml and mcp.json) on Android, iOS, and JavaScript/Node.js targets. On Android, configs are stored in the app's internal storage directory; on iOS, they are saved in the Application Support directory; and on JS/Node.js, they are placed in the user's home directory (with a /tmp fallback for browser environments). This change ensures that user settings, model configurations, and MCP server definitions are persisted securely and appropriately for each operating system.
mpp-core/src/androidMain/kotlin/cc/unitmesh/config, mpp-core/src/iosMain/kotlin/cc/unitmesh/config, mpp-core/src/jsMain/kotlin/cc/unitmesh/config · high confidence
Platform-specific implementations for ArtifactBundlePacker on Android, iOS, and WASM
This change adds platform-specific implementations of the ArtifactBundlePacker for Android, iOS, and WASM targets. On Android, the packer now fully supports creating, extracting, and unpacking artifact bundles as ZIP files using standard Java I/O libraries. For iOS and WASM, stub implementations are provided that return errors for ZIP operations, noting that full support requires platform-specific libraries (such as NSFileManager for iOS or browser APIs for WASM), though basic in-memory bundle utilities are available for serialization and deserialization.
mpp-core/src/androidMain/kotlin/cc/unitmesh/agent/artifact, mpp-core/src/iosMain/kotlin/cc/unitmesh/agent/artifact, mpp-core/src/wasmJsMain/kotlin/cc/unitmesh/agent/artifact · high confidence
Platform-specific validation for iOS and WASM targets
The NanoDSL parser now includes platform-specific validation implementations for iOS and WASM JavaScript targets. These implementations perform basic syntax checks (such as verifying component definitions, indentation, and balanced brackets) and return a source-only intermediate representation, ensuring that DSL validation works consistently across these platforms even though full AST parsing is restricted to JVM.
mpp-core/src/iosMain/kotlin/cc/unitmesh/agent/parser, mpp-core/src/wasmJsMain/kotlin/cc/unitmesh/agent/parser · high confidence
Support for custom OpenAI-compatible LLM providers
Users can now connect to any OpenAI-compatible API endpoint (such as GLM, custom self-hosted models, or GitHub Copilot) by providing a custom base URL and API key. This new client implementation allows for flexible configuration of the chat completions path and supports passing custom HTTP headers in requests, enabling integration with a wider variety of third-party or internal LLM services that follow the OpenAI protocol.
mpp-core/src/commonMain/kotlin/cc/unitmesh/llm/clients · high confidence
Support for dynamic Claude Skills and SpecKit command loading
The command module now introduces two new command types that allow agents to discover and execute external instructions dynamically. ClaudeSkillCommand enables the loading of 'Claude Skills' from project root directories or the user's \~/.claude/skills/ directory, parsing SKILL.md files to expose them as dotted commands (e.g., /skill.pdf). SpecKitCommand provides similar dynamic loading for GitHub Spec-Kit prompts found in .github/prompts/, compiling templates with frontmatter variables and file content injection via SpecKitTemplateCompiler. Users can now extend agent capabilities by simply adding these structured markdown files to their project or user directories without code changes.
mpp-core/src/commonMain/kotlin/cc/unitmesh/devins/command · high confidence
Support for external CLI coding agents (Claude, Codex) with workspace change tracking
Users can now run external coding agents like Claude Code and Codex CLI through the platform. The new \ExternalCliCodingAgent\ executes these tools via shell commands, supporting both interactive and non-interactive modes, and automatically detects file changes in the workspace by comparing git status snapshots before and after execution. This allows the platform to display edits made by external agents as if they were performed internally.
mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/external · high confidence
iOS code parsing and graph generation support
The iOS platform now supports code analysis via a new \IosCodeParser\ implementation that uses regex-based parsing to extract code structure and import information for Java, Kotlin, JavaScript, TypeScript, Python, Go, and Rust. This change enables the \CodeGraphFactory\ on iOS to generate code graphs containing nodes and relationships, allowing users to visualize code structure directly on iOS devices without relying on server-side or JavaScript-based parsing.
mpp-codegraph/src/iosMain · high confidence
iOS platform support for agent tools
The agent tool layer now supports iOS, providing platform-specific implementations for code parsing, HTTP networking, and file operations. Code parsing utilizes the iOS-specific IosCodeParser, HTTP requests are handled via Ktor with the Darwin engine, and .gitignore parsing uses the iOS Foundation framework. Shell execution is explicitly unsupported on iOS and returns an error when invoked.
mpp-core/src/iosMain/kotlin/cc/unitmesh/agent/tool · high confidence
iOS platform support with stubbed Git operations
The application now supports the iOS platform by introducing an iOS-specific implementation of the Git operations interface. However, because Git functionality is not supported on iOS, all methods in this implementation are stubbed to return empty results or null values, and the \isSupported\ flag is set to false, meaning Git features will effectively be disabled for iOS users.
mpp-core/src/iosMain/kotlin/cc/unitmesh/agent/platform · high confidence
Architecture
New provider-based tool registry system
The agent's tool management has been refactored to use a provider-based architecture. A new \ToolProviderRegistry\ and \ToolProvider\ interface allow tools to be registered via providers (such as \BuiltinToolsProvider\) that declare dependencies like file systems, shell executors, and LLM services. The \ToolRegistry\ now discovers and registers these tools automatically at initialization, supporting case-insensitive lookups and providing example usage strings for built-in tools. This change centralizes tool discovery and simplifies adding new tools by simply registering them in a provider.
mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/tool/registry · high confidence
Behavioural changes
Added Node.js polyfills and WASM asset handling for browser-based tests
A new webpack configuration file has been introduced to enable running tests in a browser environment by providing fallbacks for unavailable Node.js core modules (such as fs, path, and crypto) and configuring the build to copy necessary WebAssembly assets (like tree-sitter and lg2\_async) to the output directory. This change also suppresses warnings for dynamic requires within wasm-git, ensuring that the browser-based test suite can execute without resolution errors.
mpp-core/webpack.config.d · high confidence
Added platform-specific linter registration stubs for Android, iOS, and WASM-JS
The linter module now includes platform-specific registration files for Android, iOS, and WASM-JS. These files implement the \registerPlatformLinters\ function as empty stubs, reflecting that linters are typically executed on development machines rather than on these target platforms, or that shell execution is not yet supported in WASM. This change ensures the multiplatform linter infrastructure compiles and links correctly across these platforms without attempting to run linters at runtime.
mpp-core/src/androidMain/kotlin/cc/unitmesh/agent/linter, mpp-core/src/iosMain/kotlin/cc/unitmesh/agent/linter, mpp-core/src/wasmJsMain/kotlin/cc/unitmesh/agent/linter · high confidence
Android SQL validator uses regex-based validation instead of full parsing
On Android, the SqlValidator now performs basic syntax validation using regular expressions rather than a full SQL parser. This implementation checks for valid statement starts, balanced parentheses, and extracts table names from common clauses (SELECT, INSERT, UPDATE, DELETE, CREATE, ALTER, DROP, TRUNCATE) to support table whitelisting. Users should note that this regex-based approach is less robust than the full parsing available on Desktop JVM platforms, potentially missing complex SQL structures or edge cases that a full parser would catch.
mpp-core/src/androidMain/kotlin/cc/unitmesh/agent/subagent · high confidence
Android-specific LLM executor and GitHub Copilot registration behavior
On Android, the LLM client provider for GitHub Copilot is no longer auto-registered (the function returns null), and the executor is now created synchronously using runBlocking to wrap the asynchronous provider call.
mpp-core/src/androidMain/kotlin/cc/unitmesh/llm · high confidence
Automated package.json update for @xiuper/mpp-core
A new build script, fix-package-json.js, has been added to the mpp-core/scripts directory to automatically update the generated JavaScript library's package.json. This script reads the version from gradle.properties and sets the package name to @xiuper/mpp-core, ensuring the published artifact uses the correct scope and version without manual intervention.
mpp-core/scripts · high confidence
Browser test environment now supports WebAssembly-based code analysis
Browser-based tests for the codegraph module can now successfully run WebAssembly-dependent features (specifically web-tree-sitter) by automatically polyfilling missing Node.js core modules (such as fs, path, and crypto) and copying the required tree-sitter WASM files to the output directory.
mpp-codegraph/webpack.config.d · high confidence
DocQL search results now include smart summaries, detailed result dialogs, and improved formatting
The DocQL tool now provides richer, more structured search results. Users will see a concise smart summary in the tool call header (e.g., "Found 12 results: AuthService (class), authenticate (function)") and can open a detailed results dialog to view full formatted output, section content previews, and an unformatted raw results tab. Search results are reranked and deprioritize noisy files (like CHANGELOGs and lockfiles) and directories (like node\_modules), while unknown entities are filtered out. The formatter now includes inline line numbers for code entities, supports constructor entities, and formats file paths for readability. Direct queries support a returnAll option to bypass truncation, and keyword searches execute in parallel across multiple channels before merging and reranking.
mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/tool/impl/docql · high confidence
Git operations now gracefully degrade on Android
The Android-specific implementation of GitOperations has been added to handle the absence of native Git tooling on Android devices. Instead of failing, Git-related features (such as cloning, diffing, and commit history) now return empty results or null values, allowing the ErrorRecoveryAgent to automatically skip Git-based analysis on this platform.
mpp-core/src/androidMain/kotlin/cc/unitmesh/agent/platform · high confidence
Improved diff accuracy and structured walkthrough extraction
The code review agent now provides more accurate change statistics and unified diffs by leveraging Git operations when available, falling back to an LCS-based algorithm only when Git is unsupported. Additionally, the agent can now extract structured walkthrough content from analysis outputs by parsing specific HTML comment markers, allowing for clearer presentation of review insights.
mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/util · high confidence
Interactive shell execution support in JavaScript environment
The JavaScript platform implementation of the shell executor now supports interactive mode. When the inheritIO configuration is enabled, commands are executed using Node.js spawn with stdio inherit, allowing real-time terminal output and TTY-dependent CLI tools to function correctly. Non-interactive commands continue to use exec for output capture. This change enables the agent to run interactive coding tools and CLIs that require a live terminal connection.
mpp-core/src/jsMain/kotlin/cc/unitmesh/agent/tool/shell · high confidence
Introduce ACP agent support and new configuration structures
The configuration system now supports external ACP (Agent Client Protocol) agents, allowing users to define and activate agents like Auggie, Kimi, or Claude via the \acpAgents\ and \activeAcpAgent\ fields in the config file. This change also introduces new configuration sections for issue trackers (GitHub, GitLab, Jira), cloud storage (currently Tencent COS), and remote server settings, alongside a migration from \VisionModelConfig\ to \NamedModelConfig\ for LLM definitions. The \ConfigManager\ API has been updated to handle these new structures, including methods for saving MCP servers, remote server configs, and workspace info.
mpp-core/src/commonMain/kotlin/cc/unitmesh/config · high confidence
Introduce CompilerContext and structured logging for DevIns compilation
The compiler now uses a dedicated CompilerContext to manage compilation state, including a variable table that preserves user-defined variables during resets, and a new CompilerLogger that replaces direct output with structured, level-based logging (debug, info, warn, error) via kotlin-logging. Compilation timing has been updated to use Kotlin's Clock.System for cross-platform compatibility, and the DevInsCompiledResult now exposes detailed statistics and configuration options such as debug mode, strict mode, and template compilation settings.
mpp-core/src/commonMain/kotlin/cc/unitmesh/devins/compiler/context · high confidence
Introduce DevIns lexer with context-aware special character recognition
The DevIns lexer in \mpp-core\ has been implemented in Kotlin to replace the previous Flex-based approach, introducing a state machine that handles tokens such as agents (@), commands (/), variables ($), and code blocks. A key behavioral change is the restriction of special character recognition to line starts or positions following whitespace, which prevents the misinterpretation of standard text like email addresses or file paths as commands or variables.
mpp-core/src/commonMain/kotlin/cc/unitmesh/devins/lexer · high confidence
Introduce unified agent executor architecture with streaming and parallel tool support
The agent execution engine has been refactored to use a shared BaseAgentExecutor, consolidating common logic for conversation management, LLM response handling, and iteration control. This change introduces configurable LLM streaming support, allowing responses to be rendered in real-time chunks rather than waiting for full completion. Additionally, the CodingAgentExecutor now supports parallel execution of multiple tool calls by default, significantly improving performance for tasks requiring multiple independent operations, while still allowing a single-tool-per-iteration mode for stricter control. New dedicated executors for Code Review and Document agents leverage this unified foundation, enabling consistent behavior across different agent types.
mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/executor · high confidence
Introduces structured tool orchestration with policy checks, async shell support, and retry logic
The orchestrator module now uses new data classes (ToolExecutionContext, ToolExecutionResult, ToolCall, ToolExecutionState) to manage tool execution with richer metadata, including execution IDs, parent-child relationships, and retry tracking. The ToolOrchestrator enforces policy decisions (allow, deny, ask user) before running tools and supports asynchronous shell execution via PTY sessions, returning a pending result immediately while monitoring the session in the background. This enables live terminal output in the UI and allows users to cancel running commands, with proper state tracking for success, failure, cancellation, and retry attempts.
mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/orchestrator · high confidence
JS logging redirected to stderr to protect JSON-RPC stdout
The JavaScript platform logging implementation now redirects all console output (log, info, warn, debug) to stderr. This ensures that stdout remains clean for JSON-RPC communication, preventing log messages from interfering with the protocol when running in ACP agent mode.
mpp-core/src/jsMain/kotlin/cc/unitmesh/agent/logging · high confidence
JS tool configuration manager and multiplatform time utility
The JavaScript platform now exposes a dedicated tool configuration manager (JsToolConfigManager) and data classes (JsToolConfigFile, JsChatConfig) to handle loading, saving, and summarizing tool settings from the local file system. A key behavioral change is that built-in tools are now always enabled by default, with the previous toggle mechanism removed and the corresponding configuration field marked as deprecated. Additionally, a multiplatform utility for retrieving the current time in milliseconds has been implemented for the JS target to support time-sensitive operations.
mpp-core/src/jsMain/kotlin/cc/unitmesh/agent/config · high confidence
JVM implementation for launching MCP processes via stdio
The JVM-specific module now includes a concrete implementation of the MCP process launcher that uses ProcessBuilder to start external commands. This allows the agent to communicate with MCP servers over standard input/output streams, supporting configurable working directories, environment variable inheritance from the login shell, and custom environment overrides.
mpp-core/src/jvmMain/kotlin/cc/unitmesh/agent/mcp · high confidence
JVM logging now uses Logback with configurable file output
The JVM-specific logging implementation has been replaced with a Logback-based system. This change introduces a dedicated initializer that loads configuration from logback.xml on the classpath and ensures log files are stored in the user's home directory under .autodev/logs. Users can now control log formatting and output via standard Logback configuration files, and the system provides utilities to check log file existence and size.
mpp-core/src/jvmMain/kotlin/cc/unitmesh/agent/logging · high confidence
JVM platform linter registry now includes 19 supported linters
The JVM-specific linter registration file has been added to explicitly register 19 supported linters (including Actionlint, Biome, Checkov, Detekt, ESLint, Gitleaks, GolangciLint, Hadolint, HTMLHint, Markdownlint, PMD, Pylint, Ruff, Semgrep, ShellCheck, SQLFluff, SwiftLint, and Yamllint) into the central registry. This ensures that all these code analysis tools are automatically available for use on JVM-based platforms.
mpp-core/src/jvmMain/kotlin/cc/unitmesh/agent/linter · high confidence
JVM shell execution now supports live terminal output and login environment inheritance
The JVM shell executor now uses a pseudo-terminal (PTY) via Pty4J when available (non-headless environments) to provide live terminal output streaming and more accurate terminal emulation; it also loads the user's login shell environment (e.g., .zshrc/.bash\_profile) to ensure user-installed tools like Homebrew are available on the PATH. If PTY is unavailable or inheritIO is enabled, it falls back to a standard ProcessBuilder with augmented PATH and timeout handling. This change improves command execution reliability and visibility in IDEs and GUI contexts.
mpp-core/src/jvmMain/kotlin/cc/unitmesh/agent/tool/shell · high confidence
JVM-specific HTTP and CodeParser implementations added
The JVM module now includes platform-specific factories for HTTP client creation and code parsing. The new HttpClientFactory configures a Ktor CIO engine with specific connection and timeout settings, while HttpFetcherFactory delegates to a Ktor-based implementation. Additionally, a JvmCodeParserFactory provides the JVM-specific CodeParser implementation, enabling the agent to fetch web content and parse code using JVM-native libraries.
mpp-core/src/jvmMain/kotlin/cc/unitmesh/agent/tool/impl · high confidence
JavaScript platform linter integration and summary formatting
The JavaScript platform now exposes a dedicated linter registry and detection API via \JsLinterRegistry\ and \JsLintDetector\, allowing JS consumers to retrieve linter summaries, find applicable linters for specific files, and detect available system linters. This change also introduces a redesigned, formatted linter summary output that groups results by severity (errors, warnings, info) and registers a comprehensive set of platform-specific linters, including ESLint, Pylint, Ruff, Semgrep, and ShellCheck.
mpp-core/src/jsMain/kotlin/cc/unitmesh/agent/linter · high confidence
LLM core refactored with centralized state management and extensible provider architecture
The LLM core module has been restructured to support a more flexible and testable architecture. A new LLMServiceManager provides reactive, StateFlow-based configuration management, allowing UI components to update model settings dynamically without recreating service instances. The previous service implementation has been replaced by a new LLMService that leverages a centralized ExecutorFactory to create executors for a wide range of providers, including OpenAI, Anthropic, Google, DeepSeek, Ollama, OpenRouter, GLM, Qwen, Kimi, MiniMax, and GitHub Copilot. To support extensibility, a new LLMClientRegistry and LLMClientProvider interface allow platform-specific or third-party providers (like GitHub Copilot on JVM) to be registered without modifying the core factory. Additionally, a PromptStreamingService interface and its KoogPromptStreamingServiceAdapter have been introduced to decouple agents from the concrete LLM implementation, improving testability. The ModelConfig data class has been enhanced to support custom HTTP headers, custom request body fields, and configurable JSON paths for extracting content from streaming responses, enabling support for custom OpenAI-compatible providers.
mpp-core/src/commonMain/kotlin/cc/unitmesh/llm · high confidence
MCP process launching now explicitly unsupported on Android, iOS, JS, and WasmJS
The MCP stdio process launcher has been implemented for Android, iOS, JavaScript, and WebAssembly platforms, but each returns a clear 'not supported' error when invoked. This ensures that attempts to launch MCP processes on these platforms fail gracefully with a specific exception rather than causing undefined behavior or crashes, aligning with the platform's current limitations.
(repo-wide) · high confidence
Markdown text extraction utilities moved to core module
The MarkdownTextParser object, which provides pure utility functions for extracting text from Markdown AST nodes (such as headers, code fences, table cells, links, and images), has been relocated to the mpp-core common module. This change makes these parsing helpers available for use across other parts of the application that depend on mpp-core, facilitating shared logic without requiring Compose dependencies.
mpp-core/src/commonMain/kotlin/cc/unitmesh/markdown · high confidence
Migrate YAML parsing to kaml library
The YAML parsing implementation in mpp-core has been switched from snakeyaml to the kaml library. This change introduces a new YamlUtils utility object that provides compatibility with the previous snakeyaml interface, ensuring that existing code relying on YAML loading and serialization continues to function without modification while benefiting from the underlying library switch.
mpp-core/src/commonMain/kotlin/cc/unitmesh/yaml · high confidence
NanoDSL validation now supports bare components and provides platform-specific parsing
The NanoDSL parser in mpp-core now accepts 'bare components' (e.g., \VStack:\) without requiring an explicit \component Name:\ declaration, broadening the syntax users can write. To support this, platform-specific validation implementations were added for Android and JVM; these attempt to use the full \xiuper-ui\ parser via reflection when available, but fall back to a basic validator that checks for balanced brackets, disallows tabs, and warns about unknown components if the full parser is missing.
mpp-core/src/androidMain/kotlin/cc/unitmesh/agent/parser, mpp-core/src/jvmMain/kotlin/cc/unitmesh/agent/parser · high confidence
New self-describing tool architecture with async shell support
The agent tool system has been refactored to use a self-describing model where tools carry their own metadata (name, display name, category, schema) via the new \ExecutableTool\ and \ToolMetadata\ structures, replacing the previous \ToolType\ sealed class which is now deprecated. This change introduces a \ToolResult\ hierarchy that supports asynchronous execution through a new \Pending\ result type, enabling live terminal output for shell commands, and adds a \ToolInvocation\ interface for validated, context-aware tool execution. The diff also includes comprehensive error handling via \ToolErrorType\ and \ToolException\, and defines the core tool registry structure including sub-agents like NanoDSL and DomainDict.
mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/tool · high confidence
Platform-specific NLP keyword extraction for ChatDB
Keyword extraction from natural language queries now uses platform-specific implementations: the JVM target leverages the MyNLP library for accurate Chinese word segmentation, while iOS, JavaScript, and WebAssembly targets fall back to a regex-based tokenizer. This change improves matching accuracy for Chinese text on JVM while maintaining consistent behavior across other platforms.
(repo-wide) · high confidence
Platform-specific database connection restrictions enforced
The mpp-core module now includes platform-specific implementations for database connections that explicitly prevent direct database access on Android, iOS, JavaScript, and WASM targets. Instead of allowing direct connections, these platforms now throw an UnsupportedOperationException, guiding users to use local storage solutions (Room for Android, Core Data for iOS) or to access databases via the server API. This ensures that mobile and web clients adhere to secure and appropriate data access patterns.
(repo-wide) · high confidence
Platform-specific session storage implementation
The core library now includes platform-specific implementations for persisting chat sessions. On the JVM, sessions are saved to a JSON file in the user's home directory (\~/.autodev/sessions/chat-sessions.json), ensuring data survives application restarts. On Android, sessions are currently stored in memory only, as the implementation lacks the necessary context to access the file system; this means chat history will be lost when the app process is terminated on mobile devices.
mpp-core/src/androidMain/kotlin/cc/unitmesh/devins/llm, mpp-core/src/jvmMain/kotlin/cc/unitmesh/devins/llm · high confidence
SQL validator now supports iOS and WebAssembly platforms
The SQL validation logic in the subagent module has been migrated to multiplatform Kotlin. While the JVM implementation continues to use the full JSqlParser library for robust syntax checking, new platform-specific implementations have been added for iOS and WebAssembly. On these platforms, the validator uses regex-based detection and basic structural checks (such as balanced parentheses and valid statement starters) to validate SQL queries and enforce table whitelists, ensuring consistent behavior across all supported targets.
mpp-core/src/iosMain/kotlin/cc/unitmesh/agent/subagent, mpp-core/src/jvmMain/kotlin/cc/unitmesh/agent/subagent, mpp-core/src/wasmJsMain/kotlin/cc/unitmesh/agent/subagent · high confidence
Unified rendering architecture with artifact support and thinking block handling
The agent rendering layer has been refactored into a shared, multiplatform structure within mpp-core. A new base renderer (BaseRenderer) and a comprehensive interface (CodingAgentRenderer) now define the rendering contract, introducing support for displaying LLM thinking/reasoning blocks, tracking task execution time, and handling SQL approval requests. The system also adds an ArtifactRenderer interface for managing preview panels and console logs for generated artifacts, alongside shared data models (TimelineItem) and utility functions for formatting tool calls and identifying retrieval operations.
mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/render · high confidence
Fixes
ConfigManager now uses mutexes to prevent concurrent file access
The JVM implementation of ConfigManager has been updated to use Kotlin coroutines Mutexes for all read-modify-write operations on configuration files. This change prevents race conditions that previously caused YAML corruption (such as merged or nullified keys) when multiple threads accessed the config file simultaneously, ensuring data integrity during concurrent saves and loads.
mpp-core/src/jvmMain/kotlin/cc/unitmesh/config · high confidence
WASM platform support for LLM executor factory
Added a WASM-specific implementation of the LLM executor factory that explicitly disables GitHub Copilot integration and blocking executor creation, ensuring the application fails gracefully or directs users to async initialization methods on this platform.
mpp-core/src/wasmJsMain/kotlin/cc/unitmesh/llm · high confidence
iOS-specific LLM executor and GitHub Copilot provider stubs
Added iOS-specific implementations for the LLM executor factory. The new \ExecutorFactory.ios.kt\ file provides actual functions that return null for both GitHub Copilot auto-registration and blocking executor creation, reflecting platform limitations (e.g., no \runBlocking\ support on iOS) and the lack of GitHub Copilot support on this platform.
mpp-core/src/iosMain/kotlin/cc/unitmesh/llm · high confidence
Test coverage
Added JVM parser tests for Kotlin, Java, JavaScript, Python, and UTF-8 handling; Added JVM tests for ACP rendering, artifact bundling, and database connectivity; Added NanoDSL scenario testing harness; Added internal test infrastructure for DevIns parser and lexer; Added test coverage for Chart, DomainDict, SQL Revise, Image Extraction, and NanoDSL agents; Added test coverage for agent tools and search executors; Added tests for AgentContextDiscovery; Added tests for ChatHistoryManager session and message operations; Added tests for ClaudeSkillCommand; Added tests for CodeGraph model and JavaScript/TypeScript parser; Added tests for CodeReviewAgentExecutor; Added tests for DevIns compiler variable interpolation and command processing; Added tests for DocQL query execution and parsing; Added tests for E2E test agent models and self-healing locator; Added tests for FallbackNlpTokenizer and SchemaLinker; Added tests for GitIgnore filter functionality; Added tests for MCP tool execution and configuration; Added tests for ToolCallParser validation; Added tests for VCS diff analysis components; Added tests for WASM-specific Git log parsing, YAML handling, and in-memory file system; Added tests for WalkthroughExtractor utility; Added tests for agent tool formatting and code review fix generation; Added tests for agent tooling, plan parsing, and registry; Added tests for cross-platform YAML utility functions; Added tests for declarative tool schema generation; Added tests for document parsing, position tracking, and multi-file queries; Added tests for document scoring and search expansion components; Added tests for domain dictionary, clustering, and template engine components; Added tests for file search and tool-based command completion; Added tests for linter summary formatting and issue prioritization; Added tests for multiplatform logging configuration and initialization; Added tests for the CodeFence parser's handling of thinking blocks; Added tests for the diff parser component; Added unit tests for ConversationManager compression features; Added unit tests for Git commit message parsing; Added unit tests for LLM client configuration, model support, and compression logic; Added unit tests for WasmJsCodeParser initialization and parsing logic; Added unit tests for Workspace and WorkspaceManager; Added unit tests for linter output parsers; Added unit tests for the DevIns lexer and parser.
Dependencies
Initial multiplatform project scaffolding and dependency management
The project is initialized with a Kotlin Multiplatform structure, establishing build configurations for JVM, Android, iOS, JS, and WASM targets. This includes a centralized version catalog (libs.versions.toml) defining dependencies such as Kotlin 2.3.20, Compose 1.11.1, Ktor 3.2.2, and SQLDelight 2.1.0, alongside Gradle plugin versions for the IntelliJ Platform and Android. The setup also introduces example Python servers for custom agents and LLM integration, and configures the \mpp-core\ and \mpp-codegraph\ modules to support cross-platform code analysis and agent logic.
(dependencies) · high confidence
Upgrade Gradle wrapper to version 9.0.0
The project's Gradle wrapper has been updated to use Gradle 9.0.0. This ensures that builds are executed with the specified distribution, providing consistency across development environments and leveraging the features and improvements of the new Gradle version.
gradle · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 46 → 45 (-0.4)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.
Lenses
- Code Health 58 → 55 (-2.6)
- Architecture 88 → 89 (+0.5)
- Maturity 73 → 67 (-5.6)
- Readiness 53 → 56 (+2.5)
- Security 43 → 40 (-3.6)
- Accessibility 39 → 40 (+1.2)
- Performance 60 → 60 (+0.0)
Resolved (537)
- Ambiguous global connection state vs specific server state. isConnected implies a single boolean state for the manager, but the manager can manage multiple servers (as seen in MCPConfig and discoverServerTools). It is unclear if isConnected returns true if any server is connected, all servers are connected, or if it refers to the underlying transport connection.
- Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
- Duplicated block (10 lines × 2) (mpp-core/src/androidMain/kotlin/cc/unitmesh/agent/tool/shell/DefaultShellExecutor.kt)
- Duplicated block (10 lines × 2) (mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/executor/CodeReviewAgentExecutor.kt)
- Duplicated block (10 lines × 2) (mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/external/ExternalCliCodingAgent.kt)
- Duplicated block (10 lines × 2) (mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/scoring/DocumentReranker.kt)
- Duplicated block (10 lines × 2) (mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/tool/Tool.kt)
- Duplicated block (10 lines × 2) (mpp-core/src/commonMain/kotlin/cc/unitmesh/devins/compiler/variable/VariableTable.kt)
- Duplicated block (10 lines × 2) (mpp-core/src/jsMain/kotlin/cc/unitmesh/devins/document/CodeDocumentParser.kt)
- Duplicated block (10 lines × 2) (mpp-idea/mpp-idea-core/src/main/kotlin/cc/unitmesh/devti/bridge/BridgeRunContext.kt)
- Duplicated block (10 lines × 2) (mpp-idea/mpp-idea-core/src/main/kotlin/cc/unitmesh/devti/util/InsertUtil.kt)
- Duplicated block (10 lines × 2) (mpp-idea/mpp-idea-core/src/main/kotlin/cc/unitmesh/devti/vcs/context/DiffStrategy.kt)
- Duplicated block (10 lines × 2) (mpp-idea/mpp-idea-exts/devins-lang/src/main/kotlin/cc/unitmesh/devti/language/compiler/exec/process/LaunchProcessInsCommand.kt)
- Duplicated block (10 lines × 2) (mpp-idea/mpp-idea-lang/java/src/main/kotlin/cc/unitmesh/idea/provider/JavaTestContextProvider.kt)
- Duplicated block (10 lines × 2) (mpp-idea/src/main/kotlin/cc/unitmesh/devins/idea/renderer/terminal/IdeaAnsiTerminalRenderer.kt)
- Duplicated block (10 lines × 2) (mpp-idea/src/main/kotlin/cc/unitmesh/devins/idea/toolwindow/codereview/IdeaCodeReviewViewModel.kt)
- Duplicated block (10 lines × 2) (mpp-ui/src/commonMain/kotlin/cc/unitmesh/devins/ui/compose/document/DocumentChatPane.kt)
- Duplicated block (10 lines × 2) (mpp-viewer-web/src/jvmMain/kotlin/cc/unitmesh/viewer/web/webedit/WebEditBridge.jvm.kt)
- Duplicated block (10 lines × 2) (mpp-viewer-web/src/jvmMain/kotlin/cc/unitmesh/viewer/web/webedit/WebEditBridge.jvm.kt)
- Duplicated block (10 lines × 2) (xiuper-ui/src/commonMain/kotlin/cc/unitmesh/xuiper/ir/NanoIRConverter.kt)
- …and 517 more
New (2226)
- Banned license: com.mysql:mysql-connector-j
- Dependency hygiene PARTLY measured — Gradle build resolved part of the dependency graph, currency reported but not scored
- Duplicated block (10 lines × 2) (mpp-core/src/androidMain/kotlin/cc/unitmesh/agent/artifact/ArtifactBundlePacker.android.kt)
- Duplicated block (10 lines × 2) (mpp-core/src/androidMain/kotlin/cc/unitmesh/agent/tool/shell/DefaultShellExecutor.kt)
- Duplicated block (10 lines × 2) (mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/executor/CodeReviewAgentExecutor.kt)
- Duplicated block (10 lines × 2) (mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/external/ExternalCliCodingAgent.kt)
- Duplicated block (10 lines × 2) (mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/tool/Tool.kt)
- Duplicated block (10 lines × 2) (mpp-core/src/commonMain/kotlin/cc/unitmesh/devins/compiler/variable/VariableTable.kt)
- Duplicated block (10 lines × 2) (mpp-core/src/commonMain/kotlin/cc/unitmesh/indexer/model/DomainDictionary.kt)
- Duplicated block (10 lines × 2) (mpp-core/src/jsMain/kotlin/cc/unitmesh/devins/document/CodeDocumentParser.kt)
- Duplicated block (10 lines × 2) (mpp-idea/mpp-idea-core/src/main/kotlin/cc/unitmesh/devti/util/InsertUtil.kt)
- Duplicated block (10 lines × 2) (mpp-idea/mpp-idea-core/src/main/kotlin/cc/unitmesh/devti/vcs/context/DiffStrategy.kt)
- Duplicated block (10 lines × 2) (mpp-idea/mpp-idea-exts/devins-lang/src/main/kotlin/cc/unitmesh/devti/language/compiler/exec/process/LaunchProcessInsCommand.kt)
- Duplicated block (10 lines × 2) (mpp-idea/mpp-idea-lang/java/src/main/kotlin/cc/unitmesh/idea/provider/JavaTestContextProvider.kt)
- Duplicated block (10 lines × 2) (mpp-idea/src/main/kotlin/cc/unitmesh/devins/idea/editor/IdeaMcpConfigDialog.kt)
- Duplicated block (10 lines × 2) (mpp-idea/src/main/kotlin/cc/unitmesh/devins/idea/renderer/terminal/IdeaAnsiTerminalRenderer.kt)
- Duplicated block (10 lines × 2) (mpp-idea/src/main/kotlin/cc/unitmesh/devins/idea/toolwindow/codereview/IdeaCodeReviewViewModel.kt)
- Duplicated block (10 lines × 2) (mpp-ui/src/commonMain/kotlin/cc/unitmesh/devins/ui/compose/agent/codereview/CodeReviewSideBySideView.kt)
- Duplicated block (10 lines × 2) (mpp-ui/src/jvmMain/kotlin/cc/unitmesh/server/cli/DocumentCli.kt)
- Duplicated block (10 lines × 2) (mpp-viewer-web/src/jvmMain/kotlin/cc/unitmesh/viewer/web/webedit/WebEditBridge.jvm.kt)
- …and 2206 more
Architecture
- Unchanged — 0 containers · 11 contexts · 11 edges
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
phodal/auto-dev was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.
About this page
- The score is its most recent published measurement, taken on 13 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit e8b99f936d73bb97c6f85a8b005d035fa21b878a — the exact code this score is about.
- Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.64+preprod-569132d3dfbe.