feat: add AI agent auto-development pipeline

This commit is contained in:
2026-06-17 07:32:54 +08:00
parent bad7e66b73
commit 3b4d3dbd24
66 changed files with 6136 additions and 12 deletions

View File

@@ -12,7 +12,7 @@ EIP4 平台正式工程(路线 A'):双层制模块化单体——**保真层供
| platform-auth | 数据权限真实现(C2 已替换桩)+ P2 组织/权限 | | | platform-auth | 数据权限真实现(C2 已替换桩)+ P2 组织/权限 | |
| platform-converter | 模板转换器(P4) | 可独立 CLI 跑批 | | platform-converter | 模板转换器(P4) | 可独立 CLI 跑批 |
| platform-flow-gateway | P3 占位:Flowable 网关 | | | platform-flow-gateway | P3 占位:Flowable 网关 | |
| platform-ai | P5 占位:MCP Server | | | platform-ai | P5 AI Agent 开发底座:草稿/变更包/本地门禁/自动修复/人工部署包 | Agent 不直连线上执行生产变更 |
| platform-parity | C1 对拍框架:录制/重放/RowDiff/自对拍 CLI | P1 一级交付物 | | platform-parity | C1 对拍框架:录制/重放/RowDiff/自对拍 CLI | P1 一级交付物 |
| platform-app | Boot 启动器,组装全部模块 | ArchUnit 规则在此模块测试里 | | platform-app | Boot 启动器,组装全部模块 | ArchUnit 规则在此模块测试里 |

View File

@@ -0,0 +1,104 @@
# AI Agent 全自动开发运行说明
`platform-ai` 的自动开发入口是 `POST /api/ai/features/auto-develop`。它只在本地环境执行草稿生成、本地落库、smoke 和自动修复;线上变更只输出人工部署包,不连接线上环境执行。
## 本地运行配置
`local` 和 `dev` profile 已开启:
```yaml
spring:
sql:
init:
mode: always
schema-locations: classpath:bootstrap/bootstrap-ai-agent.sql
eip4:
ai:
store: jdbc
```
因此本地启动时会幂等创建 `sys_ai_task`、`sys_ai_draft`、`sys_ai_change_set`、`sys_ai_run`、`sys_ai_audit_log`,并用 JDBC 持久化开发证据。默认 profile 不强制写远端验证库,避免误把开发证据写到共享环境。
建议使用独立 worktree 做 Agent 功能开发,避免占用当前任务目录:
```bash
git worktree add ../eip4-platform-ai-agent -b ai/agent-dev
cd ../eip4-platform-ai-agent
```
运行态验证要先构建依赖模块并启动重新打包后的 jar,避免 `spring-boot:run -pl platform-app` 读取本地 Maven 仓库里的旧 `platform-ai`:
```bash
JAVA_HOME=/opt/homebrew/opt/openjdk@21 mvn -pl platform-app -am install -DskipTests
/opt/homebrew/opt/openjdk@21/bin/java -jar platform-app/target/platform-app-0.1.0-SNAPSHOT.jar --spring.profiles.active=local
```
## 请求示例
```bash
curl -X POST http://localhost:8093/api/ai/features/auto-develop \
-H 'Content-Type: application/json' \
-d '{
"baseUrl": "http://localhost:8093",
"generateDeploymentPackage": true,
"maxRepairAttempts": 2,
"feature": {
"objective": "新增客户等级维护功能",
"featureName": "客户等级维护",
"tableName": "EIP4AI_CUSTOMER_LEVEL",
"entityName": "客户等级",
"templateId": "eip4ai-customer-level",
"menuName": "客户等级维护",
"fields": [
{"column": "NAME", "label": "名称", "type": "string", "length": 100, "required": true},
{"column": "CODE", "label": "编码", "type": "string", "length": 64, "required": true},
{"column": "ENABLED", "label": "启用", "type": "boolean", "required": false}
]
}
}'
```
`maxRepairAttempts` 可省略,默认 2;设为 0 时只跑首轮开发和本地门禁,失败后由调用方手动调用 repair 接口。
## 自动链路
1. 创建 `AiTask`。
2. 生成 `ENTITY`、`PAGE_SCHEMA`、`SERVICEFLOW`、`MENU`、`TEST` 草稿。
3. 对草稿执行基础门禁,包括 amis schema、服务流 XML、实体字段和 smoke 计划。
4. 生成待人审 `AiChangeSet`。
5. 生成 release plan。
6. 本地 apply:实体走本机 `/api/meta/entity`,页面/服务流写本地库;如果本地最小库缺少 `sys_menu`,菜单发布标记为 `SKIPPED`,不阻断本地 gate,部署包仍保留菜单 SQL 供线上人审。
7. 本地 smoke:只允许 `localhost`、`127.0.0.1`、`::1` baseUrl;HTTP 状态必须匹配,且 JSON 响应体存在 `status` 时必须为 0。
8. 若失败,自动生成 repair plan 并执行修复重试。
9. 生成线上人工部署包,包含 manifest、SQL 草案、回滚 SQL 和本地执行证据。
返回体中的关键字段:
- `originalChangeSetId`: 首轮自动生成的变更包。
- `changeSetId`: 最终用于部署包的变更包;如果修复生成了替代草稿,可能不同于 `originalChangeSetId`。
- `repairExecutions`: 每轮自动修复证据。
- `deploymentPackage.requiresHumanApproval`: 固定为 `true`,线上发布必须人工审批。
## LLM 修复
默认使用确定性修复规则。需要外部 LLM 参与时设置:
```properties
EIP4_AI_LLM_REPAIR_ENABLED=true
EIP4_AI_LLM_REPAIR_ENDPOINT=http://127.0.0.1:18081/ai-agent/repair
EIP4_AI_LLM_REPAIR_API_KEY=...
EIP4_AI_LLM_REPAIR_MODEL=...
```
外部服务契约见 `docs/AI_AGENT_REPAIR_CONTRACT.md`。LLM 只能返回草稿补丁,不能要求平台执行生产命令。
## 线上边界
可靠路径是:本地 `auto-develop` 通过后,人工检查部署包,再由现有发布流程上线。功能上线后如果发现 bug,Agent 可以基于线上错误日志、导出的 run evidence 或人工复现结果生成新的本地任务并修复,但仍应先在本地验证,再输出人工部署包。
## 当前验证结论与遗留项
已在 `local` profile 验证完整自动开发链路:实体创建、默认服务流发布、页面 schema 发布、实体列表、默认搜索流和新增数据 smoke 均通过,最终状态为 `READY_FOR_HUMAN_REVIEW`。`local` 最小库没有菜单表,因此菜单 apply 为 `SKIPPED`,这是预期的本地边界。
遗留项是全局 metadata 辅助读路径仍有部分 SQL 写死 `eip3.` schema;在 `local/eip4m0` 下会出现非阻断 warning。AI 主链路已规避/修正必要路径,后续如果要让所有后台辅助解析在 `local` 最小库完全无噪声,需要单独做一次 schema 兼容清理。

View File

@@ -0,0 +1,155 @@
# AI Agent Repair LLM 接入契约
本文档定义 `platform-ai` 调用外部 LLM 修复服务的最小契约。该服务只负责根据失败证据生成安全草稿补丁,不直接写库、不发布线上、不访问生产环境。
## 启用配置
默认不启用外部 LLM 修复。需要显式配置:
```properties
eip4.ai.llm.repair.enabled=true
eip4.ai.llm.repair.endpoint=http://127.0.0.1:18081/ai-agent/repair
eip4.ai.llm.repair.api-key=${AI_REPAIR_API_KEY}
eip4.ai.llm.repair.model=${AI_REPAIR_MODEL}
```
`api-key` 为空时不发送 `Authorization` 头;非空时使用 `Authorization: Bearer <api-key>`。接口超时为 60 秒。服务返回非 2xx、响应格式非法或调用异常时,平台会忽略外部结果并回退到内置确定性修复规则。
## 请求格式
`HttpAiLlmRepairClient` 向配置的 endpoint 发送 `POST application/json`:
```json
{
"model": "repair-model-name",
"taskId": "ait-1",
"changeSetId": "aics-1",
"repairPlan": {
"taskId": "ait-1",
"changeSetId": "aics-1",
"sourceRunId": "run-1",
"status": "READY",
"generatedAt": 1710000000000,
"actions": [],
"messages": []
},
"drafts": [],
"contract": {
"responseField": "draftPatches",
"patchShape": "artifactType,targetId,payload,metadata",
"rule": "Return only safe draft patches; do not execute production changes"
}
}
```
字段说明:
- `repairPlan`: 平台根据最近失败的 `AUTO_DEVELOP` / `LOCAL_APPLY` / `SMOKE` 证据生成的修复计划。
- `drafts`: 当前任务的草稿快照,LLM 只能基于这些草稿生成替代草稿。
- `contract`: 平台要求的响应约束,外部服务必须遵守。
## 响应格式
外部服务必须返回 JSON 对象,且补丁数组放在 `draftPatches` 字段:
```json
{
"draftPatches": [
{
"artifactType": "ENTITY",
"targetId": "CUSTOMER",
"payload": {
"publishTarget": "/api/meta/entity",
"tableName": "SYS_CUSTOMER",
"entityName": "Customer",
"fields": []
},
"metadata": {
"source": "llm-repair",
"reason": "补齐实体发布目标"
}
}
]
}
```
`artifactType` 只允许:
- `ENTITY`
- `PAGE_SCHEMA`
- `SERVICEFLOW`
- `MENU`
- `TEST`
- `CODE`
平台当前主要自动修复 `ENTITY`、`PAGE_SCHEMA`、`SERVICEFLOW`、`MENU`、`TEST`。`CODE` 补丁即使返回,也仍然必须经过后续门禁、人审和部署包流程。
## 安全边界
外部 LLM 服务不得执行以下操作:
- 连接或修改线上数据库。
- 触发线上发布、重启、脚本执行或远程 shell。
- 绕过平台的草稿、变更包、本地 apply、smoke、部署包和人工审批流程。
- 返回除 `draftPatches` 之外需要平台立即执行的命令。
平台接收补丁后的流程是:
1. 将补丁写成新的 `AiDraft`,保留 `metadata.source` 和原因。
2. 基于同一 `artifactType + targetId` 取最新草稿重新生成 change set。
3. 执行本地 apply 和 smoke。
4. 生成线上人工部署包。
5. 线上部署仍由人工审批和发布系统执行。
## 示例:修复 TEST 契约
请求中的 `repairPlan.actions` 指出 smoke 期望状态码与实际接口不一致时,外部服务可以返回:
```json
{
"draftPatches": [
{
"artifactType": "TEST",
"targetId": "customer-smoke",
"payload": {
"smokes": [
{
"name": "打开客户列表",
"method": "GET",
"path": "/api/customer/list",
"expectedStatus": 200
}
]
},
"metadata": {
"source": "llm-repair",
"reason": "同步 smoke 期望状态码"
}
}
]
}
```
## 示例:修复 PAGE_SCHEMA
页面 schema 缺少 `type`、`title` 或 `body` 时,外部服务可以返回:
```json
{
"draftPatches": [
{
"artifactType": "PAGE_SCHEMA",
"targetId": "customer-page",
"payload": {
"type": "page",
"title": "客户管理",
"body": []
},
"metadata": {
"source": "llm-repair",
"reason": "补齐 amis 页面必填结构"
}
}
]
}
```

100
docs/sql/SYS_AI_AGENT.sql Normal file
View File

@@ -0,0 +1,100 @@
-- ============================================================================
-- 生产建表脚本:SYS_AI_AGENT(AI Agent 运行态平台表)
-- ----------------------------------------------------------------------------
-- 归属:platform-ai(P5 Agent 开发底座)。
-- 契约:/api/ai/tasks、/api/ai/tasks/{taskId}/drafts、change-sets、runs、audit。
--
-- 【Flyway 待办(P5)】
-- 架构条款(docs/架构设计.md §「平台表管理」):SYS_* 平台表由 Flyway 管理。
-- 本工程当前未引入 Flyway。本脚本即「生产建表脚本」,P5 引入 Flyway 时
-- 原样改名为 V{n}__create_sys_ai_agent.sql 纳入 src/main/resources/db/migration 即可。
-- 本地 / CI 自举副本见 platform-ai/src/main/resources/bootstrap/bootstrap-ai-agent.sql。
--
-- 边界:这些表只保存 AI 开发运行态和草稿。发布到 SYS_PAGE_SCHEMA / SYS_ENTITY /
-- 服务流等生产元数据必须经过独立人审门禁,不能由 Agent 接口直接落生产。
-- ============================================================================
CREATE TABLE IF NOT EXISTS sys_ai_task (
task_id character varying(64) NOT NULL,
objective text NOT NULL,
status character varying(32) NOT NULL,
plan_json jsonb NOT NULL,
created_at bigint NOT NULL,
updated_at bigint NOT NULL,
CONSTRAINT pk_sys_ai_task PRIMARY KEY (task_id)
);
CREATE TABLE IF NOT EXISTS sys_ai_draft (
draft_id character varying(64) NOT NULL,
task_id character varying(64) NOT NULL,
artifact_type character varying(32) NOT NULL,
target_id character varying(128) NOT NULL,
payload_json jsonb NOT NULL,
gates_json jsonb NOT NULL,
metadata_json jsonb NOT NULL,
created_at bigint NOT NULL,
CONSTRAINT pk_sys_ai_draft PRIMARY KEY (draft_id)
);
CREATE TABLE IF NOT EXISTS sys_ai_change_set (
change_set_id character varying(64) NOT NULL,
task_id character varying(64) NOT NULL,
status character varying(32) NOT NULL,
draft_ids_json jsonb NOT NULL,
summary_json jsonb NOT NULL,
created_at bigint NOT NULL,
CONSTRAINT pk_sys_ai_change_set PRIMARY KEY (change_set_id)
);
CREATE TABLE IF NOT EXISTS sys_ai_run (
run_id character varying(64) NOT NULL,
task_id character varying(64) NOT NULL,
change_set_id character varying(64) NOT NULL,
run_type character varying(32) NOT NULL,
status character varying(32) NOT NULL,
payload_json jsonb NOT NULL,
created_at bigint NOT NULL,
CONSTRAINT pk_sys_ai_run PRIMARY KEY (run_id)
);
CREATE TABLE IF NOT EXISTS sys_ai_audit_log (
audit_id character varying(64) NOT NULL,
task_id character varying(64) NOT NULL,
action character varying(96) NOT NULL,
actor character varying(64) NOT NULL,
details_json jsonb NOT NULL,
created_at bigint NOT NULL,
CONSTRAINT pk_sys_ai_audit_log PRIMARY KEY (audit_id)
);
CREATE INDEX IF NOT EXISTS idx_sys_ai_draft_task ON sys_ai_draft (task_id, created_at);
CREATE INDEX IF NOT EXISTS idx_sys_ai_change_set_task ON sys_ai_change_set (task_id, created_at);
CREATE INDEX IF NOT EXISTS idx_sys_ai_run_task ON sys_ai_run (task_id, created_at);
CREATE INDEX IF NOT EXISTS idx_sys_ai_run_change_set ON sys_ai_run (change_set_id, created_at);
CREATE INDEX IF NOT EXISTS idx_sys_ai_audit_log_task ON sys_ai_audit_log (task_id, created_at);
COMMENT ON TABLE sys_ai_task IS 'AI Agent 开发任务。只描述需求、状态和计划,不代表已发布功能';
COMMENT ON TABLE sys_ai_draft IS 'AI Agent 草稿产物。payload_json 保存实体/页面/服务流/代码等草稿';
COMMENT ON TABLE sys_ai_change_set IS 'AI Agent 待人审变更包。通过门禁后供人工确认和发布';
COMMENT ON TABLE sys_ai_run IS 'AI Agent 本地执行证据。保存 smoke/local-apply 的结构化结果';
COMMENT ON TABLE sys_ai_audit_log IS 'AI Agent 操作审计日志';
COMMENT ON COLUMN sys_ai_task.task_id IS 'Agent 任务 id';
COMMENT ON COLUMN sys_ai_task.objective IS '用户目标或需求描述';
COMMENT ON COLUMN sys_ai_task.status IS '任务状态,例如 DRAFTING / READY_FOR_REVIEW';
COMMENT ON COLUMN sys_ai_task.plan_json IS 'Agent 计划步骤 JSON';
COMMENT ON COLUMN sys_ai_task.created_at IS '创建时间 epoch 毫秒';
COMMENT ON COLUMN sys_ai_task.updated_at IS '更新时间 epoch 毫秒';
COMMENT ON COLUMN sys_ai_draft.artifact_type IS '草稿类型:ENTITY / PAGE_SCHEMA / SERVICEFLOW / MENU / CODE / TEST';
COMMENT ON COLUMN sys_ai_draft.target_id IS '目标标识,例如实体编码、templateId、服务流 id 或文件路径';
COMMENT ON COLUMN sys_ai_draft.payload_json IS '草稿内容 JSON';
COMMENT ON COLUMN sys_ai_draft.gates_json IS '草稿门禁结果 JSON';
COMMENT ON COLUMN sys_ai_draft.metadata_json IS '来源、上下文、生成参数等附加信息';
COMMENT ON COLUMN sys_ai_change_set.draft_ids_json IS '纳入变更包的 draft_id 列表';
COMMENT ON COLUMN sys_ai_change_set.summary_json IS '变更摘要、风险、人审要求和回滚提示';
COMMENT ON COLUMN sys_ai_run.run_type IS '执行类型:SMOKE / LOCAL_APPLY / AUTO_DEVELOP / REPAIR_PLAN / REPAIR_EXECUTION';
COMMENT ON COLUMN sys_ai_run.status IS '执行状态:PASSED / FAILED / APPLY_FAILED / SMOKE_FAILED 等';
COMMENT ON COLUMN sys_ai_run.payload_json IS '执行结果 JSON,包含逐条 smoke 或 apply step 详情';
COMMENT ON COLUMN sys_ai_audit_log.details_json IS '操作详情 JSON';

View File

@@ -18,7 +18,7 @@ eip4-platform(Maven 多模块单体)
├── platform-auth P2:组织/权限/数据权限真实现(替换 PoC 桩) ├── platform-auth P2:组织/权限/数据权限真实现(替换 PoC 桩)
├── platform-flow-gateway Flowable REST 客户端、待办聚合、3 个 handler bean ├── platform-flow-gateway Flowable REST 客户端、待办聚合、3 个 handler bean
├── platform-converter 模板转换器 + S3 脚本改写器(可独立 CLI 跑批) ├── platform-converter 模板转换器 + S3 脚本改写器(可独立 CLI 跑批)
├── platform-ai MCP Server、schema 双闸校验 ├── platform-ai AI Agent 开发底座、schema 双闸校验、自动修复、本地门禁和人工部署包
├── platform-parity C1 逐行对拍框架:录制/重放/逐行 diff(P1 一级交付物,可独立 CLI 跑批) ├── platform-parity C1 逐行对拍框架:录制/重放/逐行 diff(P1 一级交付物,可独立 CLI 跑批)
└── platform-app Spring Boot 启动器,组装上述模块 └── platform-app Spring Boot 启动器,组装上述模块
``` ```

View File

@@ -13,5 +13,11 @@
<description>P5 占位:MCP Server、schema 双闸校验</description> <description>P5 占位:MCP Server、schema 双闸校验</description>
<dependencies> <dependencies>
<dependency><groupId>com.eip4</groupId><artifactId>platform-legacy-core</artifactId></dependency> <dependency><groupId>com.eip4</groupId><artifactId>platform-legacy-core</artifactId></dependency>
<dependency><groupId>com.eip4</groupId><artifactId>platform-converter</artifactId></dependency>
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency>
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-jdbc</artifactId></dependency>
<dependency><groupId>org.springdoc</groupId><artifactId>springdoc-openapi-starter-webmvc-ui</artifactId></dependency>
<dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>jackson-databind</artifactId></dependency>
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency>
</dependencies> </dependencies>
</project> </project>

View File

@@ -0,0 +1,10 @@
package com.eip4.platform.ai.model;
import java.util.List;
public record AiAgentRepairContext(
String taskId,
String changeSetId,
AiRepairPlan repairPlan,
List<AiDraft> drafts) {
}

View File

@@ -0,0 +1,9 @@
package com.eip4.platform.ai.model;
import java.util.List;
public record AiAgentRepairResult(
String status,
List<AiRepairDraftPatch> draftPatches,
List<String> messages) {
}

View File

@@ -0,0 +1,20 @@
package com.eip4.platform.ai.model;
import java.util.List;
public record AiApplyRun(
String taskId,
String changeSetId,
String baseUrl,
String status,
long startedAt,
long finishedAt,
List<AiApplyStepResult> steps,
AiSmokeRun smokeRun) {
public boolean passed() {
boolean stepsPassed = steps != null && steps.stream()
.allMatch(s -> "APPLIED".equals(s.status()) || "SKIPPED".equals(s.status()));
return stepsPassed && smokeRun != null && smokeRun.passed();
}
}

View File

@@ -0,0 +1,12 @@
package com.eip4.platform.ai.model;
import java.util.Map;
public record AiApplyStepResult(
String id,
AiArtifactType artifactType,
String target,
String status,
String message,
Map<String, Object> details) {
}

View File

@@ -0,0 +1,15 @@
package com.eip4.platform.ai.model;
/**
* Agent 允许产生的受控产物类型。
*
* <p>这里刻意不用自由字符串:后续 MCP 工具、发布门禁和审计都需要按类型施加不同规则。
*/
public enum AiArtifactType {
ENTITY,
PAGE_SCHEMA,
SERVICEFLOW,
MENU,
CODE,
TEST
}

View File

@@ -0,0 +1,12 @@
package com.eip4.platform.ai.model;
import java.util.Map;
public record AiAuditEntry(
String id,
String taskId,
String action,
String actor,
long createdAt,
Map<String, Object> details) {
}

View File

@@ -0,0 +1,19 @@
package com.eip4.platform.ai.model;
public record AiAutoDevelopmentRequest(
AiFeatureRequest feature,
String baseUrl,
Boolean generateDeploymentPackage,
Integer maxRepairAttempts) {
public boolean shouldGenerateDeploymentPackage() {
return generateDeploymentPackage == null || generateDeploymentPackage;
}
public int repairAttemptLimit() {
if (maxRepairAttempts == null) {
return 2;
}
return Math.max(0, Math.min(5, maxRepairAttempts));
}
}

View File

@@ -0,0 +1,18 @@
package com.eip4.platform.ai.model;
import java.util.List;
public record AiAutoDevelopmentRun(
String taskId,
String changeSetId,
String originalChangeSetId,
String status,
long startedAt,
long finishedAt,
AiFeatureDevelopment development,
AiReleasePlan releasePlan,
AiApplyRun applyRun,
AiDeploymentPackage deploymentPackage,
List<AiRepairExecution> repairExecutions,
List<String> messages) {
}

View File

@@ -0,0 +1,13 @@
package com.eip4.platform.ai.model;
import java.util.List;
import java.util.Map;
public record AiChangeSet(
String id,
String taskId,
String status,
long createdAt,
List<String> draftIds,
Map<String, Object> summary) {
}

View File

@@ -0,0 +1,17 @@
package com.eip4.platform.ai.model;
import java.util.List;
import java.util.Map;
public record AiDeploymentPackage(
String taskId,
String changeSetId,
String status,
boolean requiresHumanApproval,
long generatedAt,
Map<String, Object> manifest,
List<String> sqlStatements,
List<String> rollbackSqlStatements,
List<String> warnings,
List<AiRunRecord> runEvidence) {
}

View File

@@ -0,0 +1,21 @@
package com.eip4.platform.ai.model;
import java.util.List;
import java.util.Map;
import com.fasterxml.jackson.databind.JsonNode;
public record AiDraft(
String id,
String taskId,
AiArtifactType artifactType,
String targetId,
JsonNode payload,
long createdAt,
List<AiGateResult> gates,
Map<String, Object> metadata) {
public boolean passed() {
return gates == null || gates.stream().allMatch(AiGateResult::passed);
}
}

View File

@@ -0,0 +1,9 @@
package com.eip4.platform.ai.model;
import java.util.List;
public record AiFeatureDevelopment(
AiTask task,
List<AiDraft> drafts,
AiChangeSet changeSet) {
}

View File

@@ -0,0 +1,9 @@
package com.eip4.platform.ai.model;
public record AiFeatureField(
String column,
String label,
String type,
Integer length,
Boolean required) {
}

View File

@@ -0,0 +1,13 @@
package com.eip4.platform.ai.model;
import java.util.List;
public record AiFeatureRequest(
String objective,
String featureName,
String tableName,
String entityName,
String templateId,
String menuName,
List<AiFeatureField> fields) {
}

View File

@@ -0,0 +1,9 @@
package com.eip4.platform.ai.model;
import java.util.List;
public record AiGateResult(
String name,
boolean passed,
List<String> messages) {
}

View File

@@ -0,0 +1,12 @@
package com.eip4.platform.ai.model;
import java.util.Map;
import com.fasterxml.jackson.databind.JsonNode;
public record AiGeneratedDraft(
AiArtifactType artifactType,
String targetId,
JsonNode payload,
Map<String, Object> metadata) {
}

View File

@@ -0,0 +1,14 @@
package com.eip4.platform.ai.model;
import java.util.List;
import java.util.Map;
public record AiReleasePlan(
String taskId,
String changeSetId,
String status,
boolean requiresHumanApproval,
Map<String, Object> environmentPolicy,
List<AiReleaseStep> steps,
List<String> rollbackNotes) {
}

View File

@@ -0,0 +1,13 @@
package com.eip4.platform.ai.model;
import java.util.Map;
public record AiReleaseStep(
String id,
AiArtifactType artifactType,
String title,
String mode,
String target,
String action,
Map<String, Object> details) {
}

View File

@@ -0,0 +1,14 @@
package com.eip4.platform.ai.model;
import java.util.Map;
public record AiRepairAction(
String id,
String source,
String actionType,
String artifactType,
String targetId,
boolean automated,
String rationale,
Map<String, Object> details) {
}

View File

@@ -0,0 +1,12 @@
package com.eip4.platform.ai.model;
import java.util.Map;
import com.fasterxml.jackson.databind.JsonNode;
public record AiRepairDraftPatch(
AiArtifactType artifactType,
String targetId,
JsonNode payload,
Map<String, Object> metadata) {
}

View File

@@ -0,0 +1,17 @@
package com.eip4.platform.ai.model;
import java.util.List;
public record AiRepairExecution(
String taskId,
String changeSetId,
String status,
long startedAt,
long finishedAt,
AiRepairPlan repairPlan,
List<AiDraft> generatedDrafts,
AiChangeSet repairedChangeSet,
AiApplyRun retryApplyRun,
AiDeploymentPackage deploymentPackage,
List<String> messages) {
}

View File

@@ -0,0 +1,4 @@
package com.eip4.platform.ai.model;
public record AiRepairExecutionRequest(String baseUrl) {
}

View File

@@ -0,0 +1,13 @@
package com.eip4.platform.ai.model;
import java.util.List;
public record AiRepairPlan(
String taskId,
String changeSetId,
String sourceRunId,
String status,
long generatedAt,
List<AiRepairAction> actions,
List<String> messages) {
}

View File

@@ -0,0 +1,13 @@
package com.eip4.platform.ai.model;
import com.fasterxml.jackson.databind.JsonNode;
public record AiRunRecord(
String id,
String taskId,
String changeSetId,
String runType,
String status,
long createdAt,
JsonNode payload) {
}

View File

@@ -0,0 +1,13 @@
package com.eip4.platform.ai.model;
public record AiSmokeResult(
String name,
String method,
String url,
int expectedHttpStatus,
int actualHttpStatus,
boolean passed,
long durationMillis,
String error,
String responseSnippet) {
}

View File

@@ -0,0 +1,17 @@
package com.eip4.platform.ai.model;
import java.util.List;
public record AiSmokeRun(
String taskId,
String changeSetId,
String baseUrl,
String status,
long startedAt,
long finishedAt,
List<AiSmokeResult> results) {
public boolean passed() {
return results != null && results.stream().allMatch(AiSmokeResult::passed);
}
}

View File

@@ -0,0 +1,12 @@
package com.eip4.platform.ai.model;
import java.util.List;
public record AiTask(
String id,
String objective,
String status,
long createdAt,
long updatedAt,
List<String> plan) {
}

View File

@@ -0,0 +1,9 @@
package com.eip4.platform.ai.service;
import com.eip4.platform.ai.model.AiAgentRepairContext;
import com.eip4.platform.ai.model.AiAgentRepairResult;
public interface AiAgentRepairExecutor {
AiAgentRepairResult repair(AiAgentRepairContext context);
}

File diff suppressed because it is too large Load Diff

View File

@@ -0,0 +1,407 @@
package com.eip4.platform.ai.service;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.HexFormat;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import org.springframework.stereotype.Component;
import com.dsasp.server.common.core.FlowDefinition;
import com.dsasp.server.core.service.flow.model.DefaultFlowHelper;
import com.eip4.platform.ai.model.AiArtifactType;
import com.eip4.platform.ai.model.AiFeatureField;
import com.eip4.platform.ai.model.AiFeatureRequest;
import com.eip4.platform.ai.model.AiGeneratedDraft;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
@Component
public class AiFeatureDraftGenerator {
private static final String ENTITY_ID_PLACEHOLDER = "${entityId}";
private static final Set<String> SYSTEM_COLUMNS = Set.of(
"VERSION", "CREATETIME", "UPDATETIME", "CREATEBY", "UPDATEBY", "ISACTIVE");
private final ObjectMapper objectMapper;
public AiFeatureDraftGenerator(ObjectMapper objectMapper) {
this.objectMapper = objectMapper;
}
public List<AiGeneratedDraft> generate(AiFeatureRequest request) {
FeatureSpec spec = normalize(request);
List<AiGeneratedDraft> drafts = new ArrayList<>();
drafts.add(new AiGeneratedDraft(AiArtifactType.ENTITY, spec.tableName(),
entityPayload(spec), metadata("entity-meta", "/api/meta/entity")));
drafts.add(new AiGeneratedDraft(AiArtifactType.PAGE_SCHEMA, spec.templateId(),
pageSchema(spec), metadata("page-schema", "sys_page_schema")));
drafts.add(new AiGeneratedDraft(AiArtifactType.SERVICEFLOW, spec.tableName() + "_DEFAULT_FLOWS",
serviceFlowPayload(spec), metadata("serviceflow", "sys_serviceflow")));
drafts.add(new AiGeneratedDraft(AiArtifactType.MENU, spec.templateId(),
menuPayload(spec), metadata("menu", "sys_menu")));
drafts.add(new AiGeneratedDraft(AiArtifactType.TEST, spec.templateId() + "-smoke",
testPayload(spec), metadata("smoke-test", "local-gates")));
return List.copyOf(drafts);
}
private ObjectNode entityPayload(FeatureSpec spec) {
ObjectNode root = objectMapper.createObjectNode();
root.put("publishTarget", "/api/meta/entity");
root.put("tablename", spec.tableName());
root.put("name", spec.entityName());
ArrayNode attrs = root.putArray("attributes");
for (FieldSpec field : spec.fields()) {
ObjectNode attr = attrs.addObject();
attr.put("column", field.column());
attr.put("display", field.label());
attr.put("type", field.type());
if (field.length() != null) {
attr.put("length", field.length());
}
attr.put("mandatory", field.required());
}
return root;
}
private ObjectNode pageSchema(FeatureSpec spec) {
ObjectNode page = objectMapper.createObjectNode();
page.put("type", "page");
page.put("title", spec.featureName());
ArrayNode body = page.putArray("body");
ObjectNode crud = body.addObject();
crud.put("type", "crud");
crud.put("name", lowerCamel(spec.tableName()) + "Crud");
crud.put("syncLocation", false);
ObjectNode api = crud.putObject("api");
api.put("method", "get");
api.put("url", "/api/entity/" + spec.tableName() + "/list?page=${page}&perPage=${perPage}");
api.put("adaptor", "return payload;");
ArrayNode headerToolbar = crud.putArray("headerToolbar");
ObjectNode addButton = headerToolbar.addObject();
addButton.put("type", "button");
addButton.put("label", "新增");
addButton.put("level", "primary");
addButton.put("icon", "fa fa-plus");
addButton.put("actionType", "dialog");
ObjectNode addDialog = addButton.putObject("dialog");
addDialog.put("title", "新增" + spec.entityName());
ObjectNode addForm = addDialog.putObject("body");
addForm.put("type", "form");
addForm.put("api", "post:/api/entity/" + spec.tableName() + "/save");
addForm.set("body", formControls(spec, false));
headerToolbar.add("pagination");
ArrayNode footerToolbar = crud.putArray("footerToolbar");
footerToolbar.add("statistics");
footerToolbar.add("pagination");
crud.put("perPage", 20);
crud.set("columns", columns(spec));
return page;
}
private ArrayNode columns(FeatureSpec spec) {
ArrayNode columns = objectMapper.createArrayNode();
for (FieldSpec field : spec.fields()) {
ObjectNode column = columns.addObject();
column.put("name", field.column());
column.put("label", field.label());
}
ObjectNode op = columns.addObject();
op.put("type", "operation");
op.put("label", "操作");
op.put("width", 180);
ArrayNode buttons = op.putArray("buttons");
ObjectNode edit = buttons.addObject();
edit.put("type", "button");
edit.put("label", "编辑");
edit.put("level", "link");
edit.put("actionType", "dialog");
ObjectNode editDialog = edit.putObject("dialog");
editDialog.put("title", "编辑${" + displayColumn(spec) + "}");
ObjectNode editForm = editDialog.putObject("body");
editForm.put("type", "form");
editForm.put("api", "post:/api/entity/" + spec.tableName() + "/save");
ArrayNode editControls = formControls(spec, true);
ObjectNode hiddenPk = objectMapper.createObjectNode();
hiddenPk.put("type", "hidden");
hiddenPk.put("name", spec.tableName() + "_ID");
hiddenPk.put("value", "${" + spec.tableName() + "_ID}");
editControls.add(hiddenPk);
editForm.set("body", editControls);
ObjectNode del = buttons.addObject();
del.put("type", "button");
del.put("label", "删除");
del.put("level", "link");
del.put("className", "text-danger");
del.put("actionType", "ajax");
del.put("confirmText", "确认删除该记录?");
ObjectNode delApi = del.putObject("api");
delApi.put("method", "post");
delApi.put("url", "/api/entity/" + spec.tableName() + "/delete");
ObjectNode data = delApi.putObject("data");
data.put("id", "${" + spec.tableName() + "_ID}");
del.put("reload", lowerCamel(spec.tableName()) + "Crud");
return columns;
}
private ArrayNode formControls(FeatureSpec spec, boolean bindCurrentRow) {
ArrayNode controls = objectMapper.createArrayNode();
for (FieldSpec field : spec.fields()) {
ObjectNode c = controls.addObject();
c.put("type", controlType(field.type()));
c.put("name", field.column());
c.put("label", field.label());
if (field.required()) {
c.put("required", true);
}
if (bindCurrentRow) {
c.put("value", "${" + field.column() + "}");
}
}
return controls;
}
private ObjectNode serviceFlowPayload(FeatureSpec spec) {
ObjectNode root = objectMapper.createObjectNode();
root.put("publishTarget", "sys_serviceflow");
root.put("requiresEntityId", true);
root.put("entityIdBinding", "publish ENTITY draft first, then replace " + ENTITY_ID_PLACEHOLDER);
ArrayNode flows = root.putArray("flows");
addFlow(flows, DefaultFlowHelper.getDefaultAdd(spec.tableName(), ENTITY_ID_PLACEHOLDER, spec.entityName()));
addFlow(flows, DefaultFlowHelper.getDefaultUpdate(spec.tableName(), ENTITY_ID_PLACEHOLDER, spec.entityName()));
addFlow(flows, DefaultFlowHelper.getDefaultSearch(spec.tableName(), ENTITY_ID_PLACEHOLDER, spec.entityName()));
addFlow(flows, DefaultFlowHelper.getDefaultDelete(spec.tableName(), ENTITY_ID_PLACEHOLDER, spec.entityName()));
addFlow(flows, DefaultFlowHelper.getDefaultLoad(spec.tableName(), ENTITY_ID_PLACEHOLDER, spec.entityName()));
return root;
}
private void addFlow(ArrayNode flows, FlowDefinition<?> flow) {
ObjectNode node = flows.addObject();
node.put("key", flow.getKey());
node.put("displayName", flow.getDisplayName());
node.put("entityId", flow.getEntityId());
node.put("control", flow.isControl());
node.put("updateable", flow.isUpdateable());
node.put("contentXml", flow.getFlow());
}
private ObjectNode menuPayload(FeatureSpec spec) {
ObjectNode root = objectMapper.createObjectNode();
root.put("publishTarget", "sys_menu");
root.put("name", spec.menuName());
root.put("typename", "功能菜单");
root.put("viewTemplateId", spec.templateId());
root.put("seq", 0);
return root;
}
private ObjectNode testPayload(FeatureSpec spec) {
ObjectNode root = objectMapper.createObjectNode();
root.put("publishTarget", "local-smoke");
ArrayNode tests = root.putArray("smokeTests");
addSmoke(tests, "page-schema", "GET", "/api/page/schema/" + spec.templateId(), 200);
addSmoke(tests, "entity-list", "GET", "/api/entity/" + spec.tableName() + "/list?page=1&perPage=20", 200);
addSmoke(tests, "flow-search", "GET", "/api/flow/" + spec.tableName() + "_SEARCH?page=1&perPage=20", 200);
ObjectNode create = addSmoke(tests, "entity-create", "POST",
"/api/entity/" + spec.tableName() + "/save", 200);
create.set("requestBody", sampleEntityBody(spec));
ArrayNode manual = root.putArray("manualGates");
manual.add("确认实体字段、菜单位置、权限角色和服务流写入策略");
manual.add("确认本地 smoke 通过后再人工部署线上");
return root;
}
private ObjectNode addSmoke(ArrayNode tests, String name, String method, String url, int expectStatus) {
ObjectNode t = tests.addObject();
t.put("name", name);
t.put("method", method);
t.put("url", url);
t.put("expectHttpStatus", expectStatus);
return t;
}
private ObjectNode sampleEntityBody(FeatureSpec spec) {
ObjectNode body = objectMapper.createObjectNode();
for (FieldSpec field : spec.fields()) {
switch (field.type()) {
case "integer" -> body.put(field.column(), 1);
case "number" -> body.put(field.column(), 1.0);
case "date" -> body.put(field.column(), "2026-01-01");
case "datetime" -> body.put(field.column(), "2026-01-01 00:00:00");
case "boolean" -> body.put(field.column(), true);
default -> body.put(field.column(), "AI_SMOKE_" + field.column());
}
}
return body;
}
private FeatureSpec normalize(AiFeatureRequest request) {
String feature = firstText(request == null ? null : request.featureName(),
request == null ? null : request.entityName(),
request == null ? null : request.objective(),
"AI功能");
String table = normalizeTable(request == null ? null : request.tableName(), feature);
String entityName = firstText(request == null ? null : request.entityName(), feature, table);
String templateId = normalizeTemplateId(request == null ? null : request.templateId(), table);
String menuName = firstText(request == null ? null : request.menuName(), feature);
List<FieldSpec> fields = normalizeFields(request == null ? null : request.fields());
return new FeatureSpec(feature, table, entityName, templateId, menuName, fields);
}
private List<FieldSpec> normalizeFields(List<AiFeatureField> input) {
List<AiFeatureField> raw = input == null ? List.of() : input;
List<FieldSpec> out = new ArrayList<>();
Set<String> seen = new LinkedHashSet<>();
for (AiFeatureField f : raw) {
String column = normalizeColumn(f == null ? null : f.column());
if (column == null || SYSTEM_COLUMNS.contains(column) || !seen.add(column)) {
continue;
}
String type = normalizeType(f.type());
Integer length = normalizeLength(type, f.length());
String label = firstText(f.label(), column);
out.add(new FieldSpec(column, label, type, length, Boolean.TRUE.equals(f.required())));
}
if (out.isEmpty()) {
out.add(new FieldSpec("NAME", "名称", "string", 100, true));
out.add(new FieldSpec("DESCRIPTION", "描述", "string", 500, false));
}
return List.copyOf(out);
}
private static String normalizeTable(String raw, String seed) {
String table = raw == null ? "" : raw.trim().toUpperCase(Locale.ROOT);
table = table.replaceAll("[^A-Z0-9_]", "_").replaceAll("_+", "_");
if (!table.matches("[A-Z][A-Z0-9_]{2,40}")) {
table = "EIP4AI_" + sha(seed).substring(0, 10).toUpperCase(Locale.ROOT);
}
if (table.length() > 40) {
table = table.substring(0, 40);
}
return table;
}
private static String normalizeTemplateId(String raw, String table) {
String id = raw == null ? "" : raw.trim();
if (id.isBlank()) {
id = table.toLowerCase(Locale.ROOT).replace('_', '-');
}
id = id.replaceAll("[^A-Za-z0-9_.:-]", "-").replaceAll("-+", "-");
return id.length() > 64 ? id.substring(0, 64) : id;
}
private static String normalizeColumn(String raw) {
if (raw == null || raw.isBlank()) {
return null;
}
String col = raw.trim().toUpperCase(Locale.ROOT).replaceAll("[^A-Z0-9_]", "_").replaceAll("_+", "_");
if (!col.matches("[A-Z][A-Z0-9_]{0,39}")) {
col = "F_" + col;
}
return col.length() > 40 ? col.substring(0, 40) : col;
}
private static String normalizeType(String raw) {
String t = raw == null ? "" : raw.trim().toLowerCase(Locale.ROOT);
return switch (t) {
case "int", "integer", "long" -> "integer";
case "number", "decimal", "double", "money" -> "number";
case "date" -> "date";
case "datetime", "time", "timestamp" -> "datetime";
case "bool", "boolean" -> "boolean";
default -> "string";
};
}
private static Integer normalizeLength(String type, Integer length) {
if (!"string".equals(type)) {
return null;
}
if (length == null || length < 1) {
return 100;
}
return Math.min(length, 2000);
}
private static String controlType(String fieldType) {
return switch (fieldType) {
case "integer", "number" -> "input-number";
case "date" -> "input-date";
case "datetime" -> "input-datetime";
case "boolean" -> "switch";
default -> "input-text";
};
}
private static String displayColumn(FeatureSpec spec) {
return spec.fields().stream()
.filter(f -> "NAME".equals(f.column()) || f.required())
.map(FieldSpec::column)
.findFirst()
.orElse(spec.fields().get(0).column());
}
private static String lowerCamel(String table) {
String[] parts = table.toLowerCase(Locale.ROOT).split("_+");
StringBuilder sb = new StringBuilder(parts[0]);
for (int i = 1; i < parts.length; i++) {
if (!parts[i].isBlank()) {
sb.append(Character.toUpperCase(parts[i].charAt(0))).append(parts[i].substring(1));
}
}
return sb.toString();
}
private static String firstText(String... values) {
for (String value : values) {
if (value != null && !value.isBlank()) {
return value.trim();
}
}
return "";
}
private static Map<String, Object> metadata(String generatorStep, String publishTarget) {
Map<String, Object> metadata = new LinkedHashMap<>();
metadata.put("source", "ai-agent");
metadata.put("generator", "deterministic-feature-v1");
metadata.put("generatorStep", generatorStep);
metadata.put("publishTarget", publishTarget);
return metadata;
}
private static String sha(String text) {
try {
MessageDigest digest = MessageDigest.getInstance("SHA-256");
return HexFormat.of().formatHex(digest.digest(String.valueOf(text).getBytes(StandardCharsets.UTF_8)));
} catch (NoSuchAlgorithmException ex) {
throw new IllegalStateException(ex);
}
}
private record FeatureSpec(
String featureName,
String tableName,
String entityName,
String templateId,
String menuName,
List<FieldSpec> fields) {
}
private record FieldSpec(
String column,
String label,
String type,
Integer length,
boolean required) {
}
}

View File

@@ -0,0 +1,6 @@
package com.eip4.platform.ai.service;
public record AiHttpResponse(
int statusCode,
String body) {
}

View File

@@ -0,0 +1,11 @@
package com.eip4.platform.ai.service;
import java.util.List;
import com.eip4.platform.ai.model.AiAgentRepairContext;
import com.eip4.platform.ai.model.AiRepairDraftPatch;
public interface AiLlmRepairClient {
List<AiRepairDraftPatch> repair(AiAgentRepairContext context);
}

View File

@@ -0,0 +1,365 @@
package com.eip4.platform.ai.service;
import java.net.URI;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.time.Duration;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HexFormat;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.UUID;
import org.springframework.http.HttpStatus;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ResponseStatusException;
import com.eip4.platform.ai.model.AiApplyStepResult;
import com.eip4.platform.ai.model.AiArtifactType;
import com.eip4.platform.ai.model.AiDraft;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
@Component
public class AiLocalReleaseExecutor {
private final JdbcTemplate jdbcTemplate;
private final AiSmokeHttpClient httpClient;
private final ObjectMapper objectMapper;
public AiLocalReleaseExecutor(JdbcTemplate jdbcTemplate, AiSmokeHttpClient httpClient, ObjectMapper objectMapper) {
this.jdbcTemplate = jdbcTemplate;
this.httpClient = httpClient;
this.objectMapper = objectMapper;
}
public List<AiApplyStepResult> apply(String baseUrl, List<AiDraft> drafts) {
URI base = safeLocalBase(baseUrl);
ApplyContext ctx = new ApplyContext(base);
List<AiApplyStepResult> results = new ArrayList<>();
for (AiDraft draft : drafts.stream().sorted(Comparator.comparingInt(d -> releaseOrder(d.artifactType()))).toList()) {
if (draft.artifactType() == AiArtifactType.TEST) {
continue;
}
AiApplyStepResult result = applyOne(ctx, draft, results.size() + 1);
results.add(result);
if ("FAILED".equals(result.status())) {
break;
}
}
return List.copyOf(results);
}
private static int releaseOrder(AiArtifactType type) {
return switch (type) {
case ENTITY -> 10;
case SERVICEFLOW -> 20;
case PAGE_SCHEMA -> 30;
case MENU -> 40;
case TEST -> 50;
case CODE -> 60;
};
}
private AiApplyStepResult applyOne(ApplyContext ctx, AiDraft draft, int index) {
try {
return switch (draft.artifactType()) {
case ENTITY -> applyEntity(ctx, draft, index);
case SERVICEFLOW -> applyServiceFlows(ctx, draft, index);
case PAGE_SCHEMA -> applyPageSchema(draft, index);
case MENU -> applyMenu(ctx, draft, index);
case CODE -> skipped(index, draft, "代码草稿暂不由平台运行时应用");
case TEST -> skipped(index, draft, "TEST 由 smoke runner 执行");
};
} catch (Exception ex) {
return new AiApplyStepResult("apply-" + index, draft.artifactType(), draft.targetId(), "FAILED",
ex.getClass().getSimpleName() + ": " + String.valueOf(ex.getMessage()), Map.of());
}
}
private AiApplyStepResult applyEntity(ApplyContext ctx, AiDraft draft, int index) throws Exception {
String tableName = draft.payload().path("tablename").asText(draft.targetId()).toUpperCase(Locale.ROOT);
AiHttpResponse response = httpClient.exchange("POST", ctx.base().resolve("/api/meta/entity"),
draft.payload(), Duration.ofSeconds(20));
if (response.statusCode() < 200 || response.statusCode() >= 300) {
return failed(index, draft, "实体发布 HTTP " + response.statusCode(), Map.of("response", response.body()));
}
JsonNode root = objectMapper.readTree(response.body());
if (root.path("status").asInt(1) != 0) {
String message = root.path("msg").asText("unknown");
if (message.contains("实体已存在")) {
List<String> ids = jdbcTemplate.queryForList(
"SELECT TRIM(sys_entity_id) FROM sys_entity WHERE tablename=? AND isactive=1",
String.class, tableName);
if (!ids.isEmpty()) {
ctx.entityId(ids.get(0));
ctx.tableName(tableName);
return applied(index, draft, "实体已存在,复用本地 entityId",
Map.of("entityId", ctx.entityId(), "tableName", ctx.tableName(), "idempotent", true));
}
}
return failed(index, draft, "实体发布失败: " + message, Map.of());
}
String entityId = root.path("data").path("entityId").asText("");
if (entityId.isBlank()) {
return failed(index, draft, "实体发布响应缺 data.entityId", Map.of());
}
ctx.entityId(entityId);
ctx.tableName(tableName);
return applied(index, draft, "实体已创建", Map.of("entityId", entityId, "tableName", ctx.tableName()));
}
private AiApplyStepResult applyServiceFlows(ApplyContext ctx, AiDraft draft, int index) {
if (ctx.entityId().isBlank()) {
return failed(index, draft, "缺少实体 entityId,不能发布服务流", Map.of());
}
long now = System.currentTimeMillis();
int count = 0;
for (JsonNode flow : draft.payload().path("flows")) {
String key = flow.path("key").asText();
String xml = flow.path("contentXml").asText().replace("${entityId}", ctx.entityId());
jdbcTemplate.update("""
INSERT INTO sys_serviceflow
(sys_serviceflow_id, displayname, contentxml, entityid, iscontrol, isupdateable,
isactive, createtime, updatetime, createby, updateby, version)
VALUES (?, ?, ?, ?, ?, ?, 1, ?, ?, 'AI_AGENT', 'AI_AGENT', 0)
ON CONFLICT (sys_serviceflow_id) DO UPDATE SET
displayname = EXCLUDED.displayname,
contentxml = EXCLUDED.contentxml,
entityid = EXCLUDED.entityid,
iscontrol = EXCLUDED.iscontrol,
isupdateable = EXCLUDED.isupdateable,
updatetime = EXCLUDED.updatetime,
updateby = EXCLUDED.updateby,
version = sys_serviceflow.version + 1
""",
key,
flow.path("displayName").asText(key),
xml,
ctx.entityId(),
flow.path("control").asBoolean(true) ? 1 : 0,
flow.path("updateable").asBoolean(true) ? 1 : 0,
now,
now);
count++;
}
return applied(index, draft, "服务流已发布", Map.of("flowCount", count, "entityId", ctx.entityId()));
}
private AiApplyStepResult applyPageSchema(AiDraft draft, int index) throws Exception {
String schemaJson = objectMapper.writeValueAsString(draft.payload());
String etag = sha256(schemaJson);
long now = System.currentTimeMillis();
jdbcTemplate.update("""
INSERT INTO sys_page_schema (template_id, name, schema_json, schema_etag, version, update_time)
VALUES (?, ?, ?::jsonb, ?, 1, ?)
ON CONFLICT (template_id) DO UPDATE SET
name = EXCLUDED.name,
schema_json = EXCLUDED.schema_json,
schema_etag = EXCLUDED.schema_etag,
version = sys_page_schema.version + 1,
update_time = EXCLUDED.update_time
""",
draft.targetId(), draft.payload().path("title").asText(draft.targetId()), schemaJson, etag, now);
return applied(index, draft, "页面 schema 已发布", Map.of("templateId", draft.targetId(), "etag", etag));
}
private AiApplyStepResult applyMenu(ApplyContext ctx, AiDraft draft, int index) {
if (!tableExists("sys_menu")) {
return skipped(index, draft, "本地库缺少 sys_menu,菜单挂载跳过,部署包保留人工 SQL");
}
String templateId = draft.payload().path("viewTemplateId").asText(draft.targetId());
String menuName = draft.payload().path("name").asText(templateId);
String parentId = textOrBlank(draft.payload().get("parentId"));
String menuRoot = textOrBlank(draft.payload().get("menuroot"));
if (parentId.isBlank()) {
ParentMenu parent = ensureAiMenuParent(menuRoot);
parentId = parent.parentId();
menuRoot = parent.menuRoot();
}
List<String> existing = jdbcTemplate.queryForList(
"SELECT TRIM(sys_menu_id) FROM sys_menu WHERE TRIM(view_templateid)=? AND isactive=1",
String.class, templateId);
String menuId = existing.isEmpty() ? UUID.randomUUID().toString() : existing.get(0);
long now = System.currentTimeMillis();
if (existing.isEmpty()) {
jdbcTemplate.update("""
INSERT INTO sys_menu
(sys_menu_id, name, parentid, view_templateid, typename, menuroot, seq,
isactive, version, createtime, createby, updatetime, updateby)
VALUES (?, ?, ?, ?, ?, ?, ?, 1, 0, ?, 'AI_AGENT', ?, 'AI_AGENT')
""",
menuId,
menuName,
parentId,
templateId,
draft.payload().path("typename").asText("功能菜单"),
menuRoot.isBlank() ? null : menuRoot,
draft.payload().path("seq").asInt(0),
now,
now);
} else {
jdbcTemplate.update("""
UPDATE sys_menu
SET name=?, parentid=?, view_templateid=?, typename=?, menuroot=?, seq=?,
updatetime=?, updateby='AI_AGENT', version=version+1
WHERE TRIM(sys_menu_id)=?
""",
menuName,
parentId,
templateId,
draft.payload().path("typename").asText("功能菜单"),
menuRoot.isBlank() ? null : menuRoot,
draft.payload().path("seq").asInt(0),
now,
menuId);
}
return applied(index, draft, "菜单已挂载", Map.of("menuId", menuId, "parentId", parentId));
}
private ParentMenu ensureAiMenuParent(String preferredRoot) {
List<String> existingDir = jdbcTemplate.queryForList(
"SELECT TRIM(sys_menu_id) FROM sys_menu WHERE name='AI Agent' AND parentid IS NULL AND isactive=1 ORDER BY seq LIMIT 1",
String.class);
if (!existingDir.isEmpty()) {
String root = preferredRoot;
if (root == null || root.isBlank()) {
List<String> roots = jdbcTemplate.queryForList(
"SELECT TRIM(menuroot) FROM sys_menu WHERE TRIM(sys_menu_id)=?",
String.class, existingDir.get(0));
root = roots.isEmpty() ? "" : roots.get(0);
}
return new ParentMenu(existingDir.get(0), root == null ? "" : root);
}
String root = preferredRoot;
if (root == null || root.isBlank()) {
List<String> roots = jdbcTemplate.queryForList(
"SELECT TRIM(sys_menu_root_id) FROM sys_menu_root WHERE isactive=1 ORDER BY seq LIMIT 1",
String.class);
if (roots.isEmpty()) {
throw new ResponseStatusException(HttpStatus.CONFLICT, "缺少 sys_menu_root,不能自动挂载菜单");
}
root = roots.get(0);
}
String dirId = UUID.randomUUID().toString();
long now = System.currentTimeMillis();
jdbcTemplate.update("""
INSERT INTO sys_menu
(sys_menu_id, name, parentid, view_templateid, typename, menuroot, seq,
isactive, version, createtime, createby, updatetime, updateby)
VALUES (?, 'AI Agent', NULL, NULL, '目录', ?, 9999, 1, 0, ?, 'AI_AGENT', ?, 'AI_AGENT')
""",
dirId, root, now, now);
return new ParentMenu(dirId, root);
}
private boolean tableExists(String tableName) {
try {
Boolean exists = jdbcTemplate.queryForObject("SELECT to_regclass(?) IS NOT NULL", Boolean.class, tableName);
return Boolean.TRUE.equals(exists);
} catch (RuntimeException ex) {
return false;
}
}
private static AiApplyStepResult applied(int index, AiDraft draft, String message, Map<String, Object> details) {
return new AiApplyStepResult("apply-" + index, draft.artifactType(), draft.targetId(),
"APPLIED", message, details);
}
private static AiApplyStepResult failed(int index, AiDraft draft, String message, Map<String, Object> details) {
return new AiApplyStepResult("apply-" + index, draft.artifactType(), draft.targetId(),
"FAILED", message, details);
}
private static AiApplyStepResult skipped(int index, AiDraft draft, String message) {
return new AiApplyStepResult("apply-" + index, draft.artifactType(), draft.targetId(),
"SKIPPED", message, Map.of());
}
private static URI safeLocalBase(String raw) {
String value = raw == null || raw.isBlank() ? "http://localhost:8084" : raw.trim();
URI uri;
try {
uri = URI.create(value);
} catch (IllegalArgumentException ex) {
throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "baseUrl 不合法: " + value);
}
String scheme = uri.getScheme();
String host = uri.getHost();
if (!"http".equalsIgnoreCase(scheme) && !"https".equalsIgnoreCase(scheme)) {
throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "baseUrl 只允许 http/https");
}
if (!isLocalHost(host)) {
throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "本地发布仅允许访问本机地址");
}
String normalized = uri.toString();
if (!normalized.endsWith("/")) {
normalized += "/";
}
return URI.create(normalized);
}
private static boolean isLocalHost(String host) {
if (host == null) {
return false;
}
String h = host.toLowerCase(Locale.ROOT);
return "localhost".equals(h) || "127.0.0.1".equals(h) || "::1".equals(h) || "[::1]".equals(h);
}
private static String textOrBlank(JsonNode node) {
if (node == null || node.isNull()) {
return "";
}
String value = node.asText("");
return value == null ? "" : value.trim();
}
private static String sha256(String text) {
try {
MessageDigest digest = MessageDigest.getInstance("SHA-256");
return HexFormat.of().formatHex(digest.digest(text.getBytes(StandardCharsets.UTF_8)));
} catch (NoSuchAlgorithmException ex) {
throw new IllegalStateException(ex);
}
}
private static class ApplyContext {
private final URI base;
private String entityId = "";
private String tableName = "";
ApplyContext(URI base) {
this.base = base;
}
URI base() {
return base;
}
String entityId() {
return entityId;
}
void entityId(String entityId) {
this.entityId = entityId == null ? "" : entityId;
}
String tableName() {
return tableName;
}
void tableName(String tableName) {
this.tableName = tableName == null ? "" : tableName;
}
}
private record ParentMenu(String parentId, String menuRoot) {
}
}

View File

@@ -0,0 +1,11 @@
package com.eip4.platform.ai.service;
import java.net.URI;
import java.time.Duration;
import com.fasterxml.jackson.databind.JsonNode;
public interface AiSmokeHttpClient {
AiHttpResponse exchange(String method, URI uri, JsonNode requestBody, Duration timeout) throws Exception;
}

View File

@@ -0,0 +1,147 @@
package com.eip4.platform.ai.service;
import java.net.URI;
import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ResponseStatusException;
import com.eip4.platform.ai.model.AiSmokeResult;
import com.eip4.platform.ai.model.AiSmokeRun;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
@Component
public class AiSmokeRunner {
private static final Duration REQUEST_TIMEOUT = Duration.ofSeconds(8);
private static final int SNIPPET_LIMIT = 600;
private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
private final AiSmokeHttpClient httpClient;
public AiSmokeRunner(AiSmokeHttpClient httpClient) {
this.httpClient = httpClient;
}
public AiSmokeRun run(String taskId, String changeSetId, String baseUrl, JsonNode testPayload) {
URI base = safeLocalBase(baseUrl);
JsonNode tests = testPayload == null ? null : testPayload.path("smokeTests");
if (tests == null || !tests.isArray() || tests.isEmpty()) {
throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "没有可执行的 smokeTests");
}
long started = System.currentTimeMillis();
List<AiSmokeResult> results = new ArrayList<>();
for (JsonNode test : tests) {
results.add(runOne(base, test));
}
long finished = System.currentTimeMillis();
boolean passed = results.stream().allMatch(AiSmokeResult::passed);
return new AiSmokeRun(taskId, changeSetId, base.toString(), passed ? "PASSED" : "FAILED",
started, finished, List.copyOf(results));
}
private AiSmokeResult runOne(URI base, JsonNode test) {
String name = text(test, "name", "unnamed");
String method = text(test, "method", "GET").toUpperCase(Locale.ROOT);
String url = text(test, "url", "");
int expected = test.path("expectHttpStatus").asInt(200);
long started = System.currentTimeMillis();
if (!url.startsWith("/api/")) {
return failed(name, method, url, expected, -1, started, "smoke url 必须以 /api/ 开头", "");
}
if (!List.of("GET", "POST", "PUT", "DELETE", "PATCH").contains(method)) {
return failed(name, method, url, expected, -1, started, "不支持的 HTTP method: " + method, "");
}
try {
URI uri = base.resolve(url);
AiHttpResponse response = httpClient.exchange(method, uri, test.get("requestBody"), REQUEST_TIMEOUT);
boolean passed = response.statusCode() == expected;
String err = passed ? businessStatusError(response.body())
: "期望 HTTP " + expected + ",实际 HTTP " + response.statusCode();
passed = passed && err.isBlank();
return new AiSmokeResult(name, method, url, expected, response.statusCode(), passed,
System.currentTimeMillis() - started, err, snippet(response.body()));
} catch (Exception ex) {
return failed(name, method, url, expected, -1, started,
ex.getClass().getSimpleName() + ": " + String.valueOf(ex.getMessage()), "");
}
}
private static AiSmokeResult failed(String name, String method, String url, int expected, int actual,
long started, String error, String response) {
return new AiSmokeResult(name, method, url, expected, actual, false,
System.currentTimeMillis() - started, error, snippet(response));
}
private static URI safeLocalBase(String raw) {
String value = raw == null || raw.isBlank() ? "http://localhost:8084" : raw.trim();
URI uri;
try {
uri = URI.create(value);
} catch (IllegalArgumentException ex) {
throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "baseUrl 不合法: " + value);
}
String scheme = uri.getScheme();
String host = uri.getHost();
if (!"http".equalsIgnoreCase(scheme) && !"https".equalsIgnoreCase(scheme)) {
throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "baseUrl 只允许 http/https");
}
if (!isLocalHost(host)) {
throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "smoke 仅允许访问本机地址");
}
String normalized = uri.toString();
if (!normalized.endsWith("/")) {
normalized += "/";
}
return URI.create(normalized);
}
private static boolean isLocalHost(String host) {
if (host == null) {
return false;
}
String h = host.toLowerCase(Locale.ROOT);
return "localhost".equals(h) || "127.0.0.1".equals(h) || "::1".equals(h) || "[::1]".equals(h);
}
private static String text(JsonNode node, String field, String fallback) {
JsonNode value = node == null ? null : node.get(field);
if (value == null || value.isNull()) {
return fallback;
}
String s = value.asText();
return s == null || s.isBlank() ? fallback : s.trim();
}
private static String snippet(String body) {
if (body == null || body.isBlank()) {
return "";
}
String compact = body.replaceAll("\\s+", " ").trim();
return compact.length() <= SNIPPET_LIMIT ? compact : compact.substring(0, SNIPPET_LIMIT);
}
private static String businessStatusError(String body) {
if (body == null || body.isBlank()) {
return "";
}
try {
JsonNode root = OBJECT_MAPPER.readTree(body);
JsonNode status = root == null || !root.isObject() ? null : root.get("status");
if (status != null && !status.isNull() && status.asInt(0) != 0) {
String msg = root.path("msg").asText("");
return msg.isBlank() ? "响应 JSON status=" + status.asText()
: "响应 JSON status=" + status.asText() + ": " + msg;
}
} catch (Exception ignore) {
return "";
}
return "";
}
}

View File

@@ -0,0 +1,321 @@
package com.eip4.platform.ai.service;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.eip4.platform.ai.model.AiAgentRepairContext;
import com.eip4.platform.ai.model.AiAgentRepairResult;
import com.eip4.platform.ai.model.AiArtifactType;
import com.eip4.platform.ai.model.AiDraft;
import com.eip4.platform.ai.model.AiRepairAction;
import com.eip4.platform.ai.model.AiRepairDraftPatch;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
@Component
public class DeterministicAiAgentRepairExecutor implements AiAgentRepairExecutor {
private final ObjectMapper objectMapper;
private final List<AiLlmRepairClient> llmRepairClients;
@Autowired
public DeterministicAiAgentRepairExecutor(ObjectMapper objectMapper, List<AiLlmRepairClient> llmRepairClients) {
this.objectMapper = objectMapper;
this.llmRepairClients = llmRepairClients == null ? List.of() : List.copyOf(llmRepairClients);
}
public DeterministicAiAgentRepairExecutor(ObjectMapper objectMapper) {
this(objectMapper, List.of());
}
@Override
public AiAgentRepairResult repair(AiAgentRepairContext context) {
if (context == null || context.repairPlan() == null || context.drafts() == null) {
return new AiAgentRepairResult("NOOP", List.of(), List.of("缺少修复上下文"));
}
AiAgentRepairResult llmResult = tryLlmRepair(context);
if (!llmResult.draftPatches().isEmpty()) {
return llmResult;
}
List<AiRepairDraftPatch> patches = new ArrayList<>();
List<String> messages = new ArrayList<>();
for (AiRepairAction action : context.repairPlan().actions()) {
if ("REPAIR_ENTITY_METADATA_OR_LOCAL_API".equals(action.actionType())) {
entityMetadataPatch(context, action).ifPresentOrElse(
patch -> {
patches.add(patch);
messages.add("已生成 ENTITY 草稿修复: " + action.targetId());
},
() -> messages.add("未找到可确定修复的 ENTITY 草稿: " + action.targetId()));
} else if ("REPAIR_SMOKE_EXPECTATION_OR_API_CONTRACT".equals(action.actionType())) {
smokeExpectationPatch(context, action).ifPresentOrElse(
patch -> {
patches.add(patch);
messages.add("已生成 TEST 草稿修复: " + action.targetId());
},
() -> messages.add("未找到可修复的 TEST 草稿: " + action.targetId()));
} else if ("REPAIR_PAGE_SCHEMA_SQL_OR_SCHEMA".equals(action.actionType())) {
pageSchemaPatch(context, action).ifPresentOrElse(
patch -> {
patches.add(patch);
messages.add("已生成 PAGE_SCHEMA 草稿修复: " + action.targetId());
},
() -> messages.add("未找到可确定修复的 PAGE_SCHEMA 草稿: " + action.targetId()));
} else if ("SEED_MENU_ROOT_OR_SET_PARENT".equals(action.actionType())
|| "REPAIR_MENU_BINDING".equals(action.actionType())) {
menuParentPatch(context, action).ifPresentOrElse(
patch -> {
patches.add(patch);
messages.add("已生成 MENU 草稿修复: " + action.targetId());
},
() -> messages.add("未找到可确定修复的 MENU 草稿: " + action.targetId()));
} else if ("RETRY_AFTER_ENTITY_ID_RESOLUTION".equals(action.actionType())
|| "REPAIR_SERVICEFLOW_XML_OR_SQL".equals(action.actionType())) {
serviceFlowEntityBindingPatch(context, action).ifPresentOrElse(
patch -> {
patches.add(patch);
messages.add("已生成 SERVICEFLOW 草稿修复: " + action.targetId());
},
() -> messages.add("未找到可确定修复的 SERVICEFLOW 草稿: " + action.targetId()));
}
}
String status = patches.isEmpty() ? "NO_PATCHES" : "PATCHES_GENERATED";
return new AiAgentRepairResult(status, List.copyOf(patches), List.copyOf(messages));
}
private AiAgentRepairResult tryLlmRepair(AiAgentRepairContext context) {
List<AiRepairDraftPatch> patches = new ArrayList<>();
List<String> messages = new ArrayList<>();
for (AiLlmRepairClient client : llmRepairClients) {
List<AiRepairDraftPatch> one = client.repair(context);
if (one != null && !one.isEmpty()) {
patches.addAll(one);
messages.add("LLM repair client generated " + one.size() + " draft patch(es)");
break;
}
}
return new AiAgentRepairResult(patches.isEmpty() ? "NO_PATCHES" : "PATCHES_GENERATED",
List.copyOf(patches), List.copyOf(messages));
}
private java.util.Optional<AiRepairDraftPatch> entityMetadataPatch(AiAgentRepairContext context,
AiRepairAction action) {
for (AiDraft draft : context.drafts()) {
if (draft.artifactType() != AiArtifactType.ENTITY || !draft.targetId().equals(action.targetId())) {
continue;
}
ObjectNode copy = draft.payload().deepCopy();
boolean changed = false;
if (!"/api/meta/entity".equals(copy.path("publishTarget").asText(""))) {
copy.put("publishTarget", "/api/meta/entity");
changed = true;
}
if (copy.path("tablename").asText("").isBlank()) {
copy.put("tablename", draft.targetId());
changed = true;
}
if (copy.path("name").asText("").isBlank()) {
copy.put("name", draft.targetId());
changed = true;
}
JsonNode attrs = copy.path("attributes");
if (attrs.isArray()) {
for (JsonNode attr : attrs) {
if (attr instanceof ObjectNode node && node.path("display").asText("").isBlank()) {
node.put("display", node.path("column").asText("字段"));
changed = true;
}
}
}
if (!changed) {
return java.util.Optional.empty();
}
return java.util.Optional.of(new AiRepairDraftPatch(
AiArtifactType.ENTITY,
draft.targetId(),
copy,
Map.of(
"source", "deterministic-agent-repair",
"repairActionId", action.id(),
"supersedesDraftId", draft.id())));
}
return java.util.Optional.empty();
}
private java.util.Optional<AiRepairDraftPatch> serviceFlowEntityBindingPatch(AiAgentRepairContext context,
AiRepairAction action) {
for (AiDraft draft : context.drafts()) {
if (draft.artifactType() != AiArtifactType.SERVICEFLOW || !draft.targetId().equals(action.targetId())) {
continue;
}
ObjectNode copy = draft.payload().deepCopy();
JsonNode flows = copy.path("flows");
if (!flows.isArray()) {
return java.util.Optional.empty();
}
boolean changed = false;
copy.put("requiresEntityId", true);
copy.put("entityIdBinding", "publish ENTITY draft first, then replace ${entityId}");
for (JsonNode flow : flows) {
if (!(flow instanceof ObjectNode node)) {
continue;
}
String existingEntityId = node.path("entityId").asText("");
String xml = node.path("contentXml").asText("");
if (!"${entityId}".equals(existingEntityId)) {
node.put("entityId", "${entityId}");
changed = true;
}
if (!xml.contains("${entityId}") && !existingEntityId.isBlank()) {
node.put("contentXml", xml.replace(existingEntityId, "${entityId}"));
changed = true;
}
}
if (!changed) {
return java.util.Optional.empty();
}
return java.util.Optional.of(new AiRepairDraftPatch(
AiArtifactType.SERVICEFLOW,
draft.targetId(),
copy,
Map.of(
"source", "deterministic-agent-repair",
"repairActionId", action.id(),
"supersedesDraftId", draft.id())));
}
return java.util.Optional.empty();
}
private java.util.Optional<AiRepairDraftPatch> menuParentPatch(AiAgentRepairContext context,
AiRepairAction action) {
for (AiDraft draft : context.drafts()) {
if (draft.artifactType() != AiArtifactType.MENU || !draft.targetId().equals(action.targetId())) {
continue;
}
ObjectNode copy = draft.payload().deepCopy();
boolean changed = false;
if (copy.path("parentId").asText("").isBlank()) {
copy.put("parentId", "${parentMenuId}");
changed = true;
}
if (copy.path("menuroot").asText("").isBlank()) {
copy.put("menuroot", "${menuRoot}");
changed = true;
}
if (!changed) {
return java.util.Optional.empty();
}
return java.util.Optional.of(new AiRepairDraftPatch(
AiArtifactType.MENU,
draft.targetId(),
copy,
Map.of(
"source", "deterministic-agent-repair",
"repairActionId", action.id(),
"supersedesDraftId", draft.id(),
"requiresHumanReplacement", true)));
}
return java.util.Optional.empty();
}
private java.util.Optional<AiRepairDraftPatch> pageSchemaPatch(AiAgentRepairContext context,
AiRepairAction action) {
for (AiDraft draft : context.drafts()) {
if (draft.artifactType() != AiArtifactType.PAGE_SCHEMA || !draft.targetId().equals(action.targetId())) {
continue;
}
ObjectNode copy = draft.payload().deepCopy();
boolean changed = false;
if (copy.path("type").asText("").isBlank()) {
copy.put("type", "page");
changed = true;
}
if (copy.path("title").asText("").isBlank()) {
copy.put("title", draft.targetId());
changed = true;
}
JsonNode body = copy.get("body");
if (body == null || body.isNull()) {
copy.putArray("body");
changed = true;
}
if (!changed) {
return java.util.Optional.empty();
}
return java.util.Optional.of(new AiRepairDraftPatch(
AiArtifactType.PAGE_SCHEMA,
draft.targetId(),
copy,
Map.of(
"source", "deterministic-agent-repair",
"repairActionId", action.id(),
"supersedesDraftId", draft.id())));
}
return java.util.Optional.empty();
}
private java.util.Optional<AiRepairDraftPatch> smokeExpectationPatch(AiAgentRepairContext context,
AiRepairAction action) {
int actual = intDetail(action, "actualHttpStatus", -1);
if (actual < 200 || actual >= 300) {
return java.util.Optional.empty();
}
String method = stringDetail(action, "method");
String url = stringDetail(action, "url");
for (AiDraft draft : context.drafts()) {
if (draft.artifactType() != AiArtifactType.TEST) {
continue;
}
ObjectNode copy = draft.payload().deepCopy();
JsonNode tests = copy.path("smokeTests");
if (!tests.isArray()) {
continue;
}
boolean changed = false;
for (JsonNode test : tests) {
if (test instanceof ObjectNode node
&& method.equalsIgnoreCase(node.path("method").asText(""))
&& url.equals(node.path("url").asText(""))) {
node.put("expectHttpStatus", actual);
changed = true;
}
}
if (changed) {
return java.util.Optional.of(new AiRepairDraftPatch(
AiArtifactType.TEST,
draft.targetId(),
copy,
Map.of(
"source", "deterministic-agent-repair",
"repairActionId", action.id(),
"supersedesDraftId", draft.id())));
}
}
return java.util.Optional.empty();
}
private static int intDetail(AiRepairAction action, String key, int fallback) {
Object value = action.details() == null ? null : action.details().get(key);
if (value instanceof Number n) {
return n.intValue();
}
if (value instanceof String s) {
try {
return Integer.parseInt(s);
} catch (NumberFormatException ignored) {
return fallback;
}
}
return fallback;
}
private static String stringDetail(AiRepairAction action, String key) {
Object value = action.details() == null ? null : action.details().get(key);
return value == null ? "" : String.valueOf(value);
}
}

View File

@@ -0,0 +1,99 @@
package com.eip4.platform.ai.service;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.stereotype.Component;
import com.eip4.platform.ai.model.AiAgentRepairContext;
import com.eip4.platform.ai.model.AiRepairDraftPatch;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
@Component
@ConditionalOnProperty(name = "eip4.ai.llm.repair.enabled", havingValue = "true")
public class HttpAiLlmRepairClient implements AiLlmRepairClient {
private static final TypeReference<List<AiRepairDraftPatch>> PATCH_LIST = new TypeReference<>() {
};
private final ObjectMapper objectMapper;
private final HttpClient httpClient;
private final URI endpoint;
private final String apiKey;
private final String model;
public HttpAiLlmRepairClient(ObjectMapper objectMapper,
@Value("${eip4.ai.llm.repair.endpoint:}") String endpoint,
@Value("${eip4.ai.llm.repair.api-key:}") String apiKey,
@Value("${eip4.ai.llm.repair.model:}") String model) {
this(objectMapper, HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(10)).build(),
endpoint, apiKey, model);
}
HttpAiLlmRepairClient(ObjectMapper objectMapper, HttpClient httpClient,
String endpoint, String apiKey, String model) {
this.objectMapper = objectMapper;
this.httpClient = httpClient;
this.endpoint = endpoint == null || endpoint.isBlank() ? null : URI.create(endpoint.trim());
this.apiKey = apiKey == null ? "" : apiKey.trim();
this.model = model == null ? "" : model.trim();
}
@Override
public List<AiRepairDraftPatch> repair(AiAgentRepairContext context) {
if (endpoint == null || context == null) {
return List.of();
}
try {
HttpRequest.Builder builder = HttpRequest.newBuilder(endpoint)
.timeout(Duration.ofSeconds(60))
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(json(requestPayload(context))));
if (!apiKey.isBlank()) {
builder.header("Authorization", "Bearer " + apiKey);
}
HttpResponse<String> response = httpClient.send(builder.build(), HttpResponse.BodyHandlers.ofString());
if (response.statusCode() < 200 || response.statusCode() >= 300) {
return List.of();
}
return parsePatches(response.body());
} catch (Exception ex) {
return List.of();
}
}
private Map<String, Object> requestPayload(AiAgentRepairContext context) {
return Map.of(
"model", model,
"taskId", context.taskId(),
"changeSetId", context.changeSetId(),
"repairPlan", context.repairPlan(),
"drafts", context.drafts(),
"contract", Map.of(
"responseField", "draftPatches",
"patchShape", "artifactType,targetId,payload,metadata",
"rule", "Return only safe draft patches; do not execute production changes"));
}
private List<AiRepairDraftPatch> parsePatches(String body) throws JsonProcessingException {
var root = objectMapper.readTree(body);
var patches = root.path("draftPatches");
if (!patches.isArray()) {
return List.of();
}
return objectMapper.convertValue(patches, PATCH_LIST);
}
private String json(Object value) throws JsonProcessingException {
return objectMapper.writeValueAsString(value);
}
}

View File

@@ -0,0 +1,46 @@
package com.eip4.platform.ai.service;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
@Component
public class JdkAiSmokeHttpClient implements AiSmokeHttpClient {
private final HttpClient httpClient;
private final ObjectMapper objectMapper;
@Autowired
public JdkAiSmokeHttpClient(ObjectMapper objectMapper) {
this(HttpClient.newHttpClient(), objectMapper);
}
JdkAiSmokeHttpClient(HttpClient httpClient, ObjectMapper objectMapper) {
this.httpClient = httpClient;
this.objectMapper = objectMapper;
}
@Override
public AiHttpResponse exchange(String method, URI uri, JsonNode requestBody, Duration timeout) throws Exception {
HttpRequest.BodyPublisher body = requestBody == null || requestBody.isNull()
? HttpRequest.BodyPublishers.noBody()
: HttpRequest.BodyPublishers.ofString(objectMapper.writeValueAsString(requestBody));
HttpRequest.Builder builder = HttpRequest.newBuilder(uri)
.timeout(timeout)
.header("Accept", "application/json");
if (requestBody != null && !requestBody.isNull()) {
builder.header("Content-Type", "application/json");
}
HttpRequest request = builder.method(method, body).build();
HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
return new AiHttpResponse(response.statusCode(), response.body());
}
}

View File

@@ -0,0 +1,33 @@
package com.eip4.platform.ai.store;
import java.util.List;
import java.util.Optional;
import com.eip4.platform.ai.model.AiAuditEntry;
import com.eip4.platform.ai.model.AiChangeSet;
import com.eip4.platform.ai.model.AiDraft;
import com.eip4.platform.ai.model.AiRunRecord;
import com.eip4.platform.ai.model.AiTask;
public interface AiAgentStore {
void saveTask(AiTask task);
Optional<AiTask> findTask(String taskId);
void saveDraft(AiDraft draft);
List<AiDraft> listDrafts(String taskId);
void saveChangeSet(AiChangeSet changeSet);
List<AiChangeSet> listChangeSets(String taskId);
void saveRun(AiRunRecord run);
List<AiRunRecord> listRuns(String taskId);
void saveAudit(AiAuditEntry entry);
List<AiAuditEntry> listAudit(String taskId);
}

View File

@@ -0,0 +1,81 @@
package com.eip4.platform.ai.store;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.stereotype.Component;
import com.eip4.platform.ai.model.AiAuditEntry;
import com.eip4.platform.ai.model.AiChangeSet;
import com.eip4.platform.ai.model.AiDraft;
import com.eip4.platform.ai.model.AiRunRecord;
import com.eip4.platform.ai.model.AiTask;
@Component
@ConditionalOnProperty(name = "eip4.ai.store", havingValue = "memory", matchIfMissing = true)
public class InMemoryAiAgentStore implements AiAgentStore {
private final Map<String, AiTask> tasks = new ConcurrentHashMap<>();
private final Map<String, List<AiDraft>> draftsByTask = new ConcurrentHashMap<>();
private final Map<String, List<AiAuditEntry>> auditByTask = new ConcurrentHashMap<>();
private final Map<String, List<AiChangeSet>> changeSetsByTask = new ConcurrentHashMap<>();
private final Map<String, List<AiRunRecord>> runsByTask = new ConcurrentHashMap<>();
@Override
public void saveTask(AiTask task) {
tasks.put(task.id(), task);
draftsByTask.computeIfAbsent(task.id(), ignored -> new CopyOnWriteArrayList<>());
auditByTask.computeIfAbsent(task.id(), ignored -> new CopyOnWriteArrayList<>());
changeSetsByTask.computeIfAbsent(task.id(), ignored -> new CopyOnWriteArrayList<>());
runsByTask.computeIfAbsent(task.id(), ignored -> new CopyOnWriteArrayList<>());
}
@Override
public Optional<AiTask> findTask(String taskId) {
return Optional.ofNullable(tasks.get(taskId));
}
@Override
public void saveDraft(AiDraft draft) {
draftsByTask.computeIfAbsent(draft.taskId(), ignored -> new CopyOnWriteArrayList<>()).add(draft);
}
@Override
public List<AiDraft> listDrafts(String taskId) {
return List.copyOf(draftsByTask.getOrDefault(taskId, List.of()));
}
@Override
public void saveChangeSet(AiChangeSet changeSet) {
changeSetsByTask.computeIfAbsent(changeSet.taskId(), ignored -> new CopyOnWriteArrayList<>()).add(changeSet);
}
@Override
public List<AiChangeSet> listChangeSets(String taskId) {
return List.copyOf(changeSetsByTask.getOrDefault(taskId, List.of()));
}
@Override
public void saveRun(AiRunRecord run) {
runsByTask.computeIfAbsent(run.taskId(), ignored -> new CopyOnWriteArrayList<>()).add(run);
}
@Override
public List<AiRunRecord> listRuns(String taskId) {
return List.copyOf(runsByTask.getOrDefault(taskId, List.of()));
}
@Override
public void saveAudit(AiAuditEntry entry) {
auditByTask.computeIfAbsent(entry.taskId(), ignored -> new CopyOnWriteArrayList<>()).add(entry);
}
@Override
public List<AiAuditEntry> listAudit(String taskId) {
return List.copyOf(auditByTask.getOrDefault(taskId, List.of()));
}
}

View File

@@ -0,0 +1,254 @@
package com.eip4.platform.ai.store;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Component;
import com.eip4.platform.ai.model.AiArtifactType;
import com.eip4.platform.ai.model.AiAuditEntry;
import com.eip4.platform.ai.model.AiChangeSet;
import com.eip4.platform.ai.model.AiDraft;
import com.eip4.platform.ai.model.AiGateResult;
import com.eip4.platform.ai.model.AiRunRecord;
import com.eip4.platform.ai.model.AiTask;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
@Component
@ConditionalOnProperty(name = "eip4.ai.store", havingValue = "jdbc")
public class JdbcAiAgentStore implements AiAgentStore {
private static final TypeReference<List<String>> STRING_LIST = new TypeReference<>() {
};
private static final TypeReference<List<AiGateResult>> GATE_LIST = new TypeReference<>() {
};
private static final TypeReference<Map<String, Object>> OBJECT_MAP = new TypeReference<>() {
};
private final JdbcTemplate jdbcTemplate;
private final ObjectMapper objectMapper;
public JdbcAiAgentStore(JdbcTemplate jdbcTemplate, ObjectMapper objectMapper) {
this.jdbcTemplate = jdbcTemplate;
this.objectMapper = objectMapper;
}
@Override
public void saveTask(AiTask task) {
jdbcTemplate.update("""
INSERT INTO sys_ai_task (task_id, objective, status, plan_json, created_at, updated_at)
VALUES (?, ?, ?, ?::jsonb, ?, ?)
ON CONFLICT (task_id) DO UPDATE SET
objective = EXCLUDED.objective,
status = EXCLUDED.status,
plan_json = EXCLUDED.plan_json,
updated_at = EXCLUDED.updated_at
""",
task.id(), task.objective(), task.status(), json(task.plan()), task.createdAt(), task.updatedAt());
}
@Override
public Optional<AiTask> findTask(String taskId) {
List<AiTask> rows = jdbcTemplate.query("""
SELECT task_id, objective, status, plan_json, created_at, updated_at
FROM sys_ai_task
WHERE task_id = ?
""", taskMapper(), taskId);
return rows.stream().findFirst();
}
@Override
public void saveDraft(AiDraft draft) {
jdbcTemplate.update("""
INSERT INTO sys_ai_draft
(draft_id, task_id, artifact_type, target_id, payload_json, gates_json, metadata_json, created_at)
VALUES (?, ?, ?, ?, ?::jsonb, ?::jsonb, ?::jsonb, ?)
ON CONFLICT (draft_id) DO UPDATE SET
artifact_type = EXCLUDED.artifact_type,
target_id = EXCLUDED.target_id,
payload_json = EXCLUDED.payload_json,
gates_json = EXCLUDED.gates_json,
metadata_json = EXCLUDED.metadata_json
""",
draft.id(), draft.taskId(), draft.artifactType().name(), draft.targetId(),
json(draft.payload()), json(draft.gates()), json(draft.metadata()), draft.createdAt());
}
@Override
public List<AiDraft> listDrafts(String taskId) {
return jdbcTemplate.query("""
SELECT draft_id, task_id, artifact_type, target_id, payload_json, gates_json, metadata_json, created_at
FROM sys_ai_draft
WHERE task_id = ?
ORDER BY created_at ASC, draft_id ASC
""", draftMapper(), taskId);
}
@Override
public void saveChangeSet(AiChangeSet changeSet) {
jdbcTemplate.update("""
INSERT INTO sys_ai_change_set
(change_set_id, task_id, status, draft_ids_json, summary_json, created_at)
VALUES (?, ?, ?, ?::jsonb, ?::jsonb, ?)
ON CONFLICT (change_set_id) DO UPDATE SET
status = EXCLUDED.status,
draft_ids_json = EXCLUDED.draft_ids_json,
summary_json = EXCLUDED.summary_json
""",
changeSet.id(), changeSet.taskId(), changeSet.status(),
json(changeSet.draftIds()), json(changeSet.summary()), changeSet.createdAt());
}
@Override
public List<AiChangeSet> listChangeSets(String taskId) {
return jdbcTemplate.query("""
SELECT change_set_id, task_id, status, draft_ids_json, summary_json, created_at
FROM sys_ai_change_set
WHERE task_id = ?
ORDER BY created_at ASC, change_set_id ASC
""", changeSetMapper(), taskId);
}
@Override
public void saveRun(AiRunRecord run) {
jdbcTemplate.update("""
INSERT INTO sys_ai_run
(run_id, task_id, change_set_id, run_type, status, payload_json, created_at)
VALUES (?, ?, ?, ?, ?, ?::jsonb, ?)
ON CONFLICT (run_id) DO UPDATE SET
run_type = EXCLUDED.run_type,
status = EXCLUDED.status,
payload_json = EXCLUDED.payload_json
""",
run.id(), run.taskId(), run.changeSetId(), run.runType(), run.status(),
json(run.payload()), run.createdAt());
}
@Override
public List<AiRunRecord> listRuns(String taskId) {
return jdbcTemplate.query("""
SELECT run_id, task_id, change_set_id, run_type, status, payload_json, created_at
FROM sys_ai_run
WHERE task_id = ?
ORDER BY created_at ASC, run_id ASC
""", runMapper(), taskId);
}
@Override
public void saveAudit(AiAuditEntry entry) {
jdbcTemplate.update("""
INSERT INTO sys_ai_audit_log
(audit_id, task_id, action, actor, details_json, created_at)
VALUES (?, ?, ?, ?, ?::jsonb, ?)
ON CONFLICT (audit_id) DO UPDATE SET
action = EXCLUDED.action,
actor = EXCLUDED.actor,
details_json = EXCLUDED.details_json
""",
entry.id(), entry.taskId(), entry.action(), entry.actor(), json(entry.details()), entry.createdAt());
}
@Override
public List<AiAuditEntry> listAudit(String taskId) {
return jdbcTemplate.query("""
SELECT audit_id, task_id, action, actor, details_json, created_at
FROM sys_ai_audit_log
WHERE task_id = ?
ORDER BY created_at ASC, audit_id ASC
""", auditMapper(), taskId);
}
private RowMapper<AiTask> taskMapper() {
return (rs, rowNum) -> new AiTask(
rs.getString("task_id"),
rs.getString("objective"),
rs.getString("status"),
rs.getLong("created_at"),
rs.getLong("updated_at"),
read(jsonText(rs, "plan_json"), STRING_LIST));
}
private RowMapper<AiDraft> draftMapper() {
return (rs, rowNum) -> new AiDraft(
rs.getString("draft_id"),
rs.getString("task_id"),
AiArtifactType.valueOf(rs.getString("artifact_type")),
rs.getString("target_id"),
readTree(jsonText(rs, "payload_json")),
rs.getLong("created_at"),
read(jsonText(rs, "gates_json"), GATE_LIST),
read(jsonText(rs, "metadata_json"), OBJECT_MAP));
}
private RowMapper<AiChangeSet> changeSetMapper() {
return (rs, rowNum) -> new AiChangeSet(
rs.getString("change_set_id"),
rs.getString("task_id"),
rs.getString("status"),
rs.getLong("created_at"),
read(jsonText(rs, "draft_ids_json"), STRING_LIST),
read(jsonText(rs, "summary_json"), OBJECT_MAP));
}
private RowMapper<AiAuditEntry> auditMapper() {
return (rs, rowNum) -> new AiAuditEntry(
rs.getString("audit_id"),
rs.getString("task_id"),
rs.getString("action"),
rs.getString("actor"),
rs.getLong("created_at"),
read(jsonText(rs, "details_json"), OBJECT_MAP));
}
private RowMapper<AiRunRecord> runMapper() {
return (rs, rowNum) -> new AiRunRecord(
rs.getString("run_id"),
rs.getString("task_id"),
rs.getString("change_set_id"),
rs.getString("run_type"),
rs.getString("status"),
rs.getLong("created_at"),
readTree(jsonText(rs, "payload_json")));
}
private String json(Object value) {
try {
return objectMapper.writeValueAsString(value);
} catch (JsonProcessingException ex) {
throw new IllegalArgumentException("AI Agent 产物 JSON 序列化失败", ex);
}
}
private <T> T read(String json, TypeReference<T> type) {
try {
return objectMapper.readValue(json, type);
} catch (JsonProcessingException ex) {
throw new IllegalArgumentException("AI Agent 产物 JSON 反序列化失败", ex);
}
}
private JsonNode readTree(String json) {
try {
return objectMapper.readTree(json);
} catch (JsonProcessingException ex) {
throw new IllegalArgumentException("AI Agent schema JSON 反序列化失败", ex);
}
}
private static String jsonText(ResultSet rs, String column) throws SQLException {
Object value = rs.getObject(column);
if (value == null) {
return "{}";
}
return String.valueOf(value);
}
}

View File

@@ -0,0 +1,178 @@
package com.eip4.platform.ai.web;
import java.util.List;
import java.util.Map;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.eip4.platform.ai.model.AiAuditEntry;
import com.eip4.platform.ai.model.AiAutoDevelopmentRequest;
import com.eip4.platform.ai.model.AiAutoDevelopmentRun;
import com.eip4.platform.ai.model.AiChangeSet;
import com.eip4.platform.ai.model.AiDeploymentPackage;
import com.eip4.platform.ai.model.AiDraft;
import com.eip4.platform.ai.model.AiFeatureDevelopment;
import com.eip4.platform.ai.model.AiFeatureRequest;
import com.eip4.platform.ai.model.AiApplyRun;
import com.eip4.platform.ai.model.AiReleasePlan;
import com.eip4.platform.ai.model.AiRepairExecution;
import com.eip4.platform.ai.model.AiRepairExecutionRequest;
import com.eip4.platform.ai.model.AiRepairPlan;
import com.eip4.platform.ai.model.AiRunRecord;
import com.eip4.platform.ai.model.AiSmokeRun;
import com.eip4.platform.ai.model.AiTask;
import com.eip4.platform.ai.service.AiAgentService;
import com.fasterxml.jackson.databind.JsonNode;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
@Tag(name = "AI Agent 开发工具", description = "受控任务/草稿/变更包/校验接口;生产发布前的人审边界")
@RestController
@RequestMapping("/api/ai")
public class AiAgentController {
private final AiAgentService service;
public AiAgentController(AiAgentService service) {
this.service = service;
}
@Operation(summary = "创建 Agent 开发任务", description = "只创建受控任务和初始计划,不执行线上变更")
@PostMapping("/tasks")
public AiTask createTask(@RequestBody CreateTaskRequest req) {
return service.createTask(req.objective());
}
@Operation(summary = "自动开发功能草稿", description = "创建任务并生成实体/页面/服务流/菜单/测试草稿,门禁通过后生成待人审变更包")
@PostMapping("/features/develop")
public AiFeatureDevelopment developFeature(@RequestBody AiFeatureRequest req) {
return service.developFeature(req);
}
@Operation(summary = "一键自动开发功能", description = "生成草稿、变更包、发布计划,执行本地落库和 smoke,并生成线上人工部署包")
@PostMapping("/features/auto-develop")
public AiAutoDevelopmentRun autoDevelopFeature(@RequestBody(required = false) AiAutoDevelopmentRequest req) {
return service.autoDevelopFeature(req);
}
@Operation(summary = "查看 Agent 开发任务")
@GetMapping("/tasks/{taskId}")
public AiTask task(@PathVariable String taskId) {
return service.getTask(taskId);
}
@Operation(summary = "保存 Agent 草稿产物", description = "PAGE_SCHEMA 草稿会自动跑 amis schema 校验")
@PostMapping("/tasks/{taskId}/drafts")
public AiDraft addDraft(@PathVariable String taskId, @RequestBody CreateDraftRequest req) {
return service.addDraft(taskId, req.artifactType(), req.targetId(), req.payload(), req.metadata());
}
@Operation(summary = "列出任务草稿")
@GetMapping("/tasks/{taskId}/drafts")
public List<AiDraft> drafts(@PathVariable String taskId) {
return service.listDrafts(taskId);
}
@Operation(summary = "在既有任务下自动开发功能草稿")
@PostMapping("/tasks/{taskId}/develop-feature")
public AiFeatureDevelopment developFeature(@PathVariable String taskId, @RequestBody AiFeatureRequest req) {
return service.developFeature(taskId, req);
}
@Operation(summary = "生成待人审变更包", description = "任何草稿门禁失败时拒绝生成")
@PostMapping("/tasks/{taskId}/change-sets")
public AiChangeSet createChangeSet(@PathVariable String taskId) {
return service.createChangeSet(taskId);
}
@Operation(summary = "列出任务变更包")
@GetMapping("/tasks/{taskId}/change-sets")
public List<AiChangeSet> changeSets(@PathVariable String taskId) {
return service.listChangeSets(taskId);
}
@Operation(summary = "生成变更包发布计划", description = "按实体→服务流→页面→菜单→smoke 排序;线上发布仍要求人工批准")
@PostMapping("/tasks/{taskId}/change-sets/{changeSetId}/release-plan")
public AiReleasePlan releasePlan(@PathVariable String taskId, @PathVariable String changeSetId) {
return service.createReleasePlan(taskId, changeSetId);
}
@Operation(summary = "运行本地 smoke 门禁", description = "只允许访问本机 baseUrl;返回逐条 HTTP smoke 结果")
@PostMapping("/tasks/{taskId}/change-sets/{changeSetId}/smoke")
public AiSmokeRun runSmoke(@PathVariable String taskId,
@PathVariable String changeSetId,
@RequestBody(required = false) SmokeRunRequest req) {
return service.runLocalSmoke(taskId, changeSetId, req == null ? null : req.baseUrl());
}
@Operation(summary = "本地应用变更包并运行 smoke", description = "仅允许本机 baseUrl;不会执行线上部署")
@PostMapping("/tasks/{taskId}/change-sets/{changeSetId}/local-apply")
public AiApplyRun localApply(@PathVariable String taskId,
@PathVariable String changeSetId,
@RequestBody(required = false) SmokeRunRequest req) {
return service.applyLocalRelease(taskId, changeSetId, req == null ? null : req.baseUrl());
}
@Operation(summary = "列出任务执行证据", description = "包含本地 smoke 和本地 apply 的结构化结果")
@GetMapping("/tasks/{taskId}/runs")
public List<AiRunRecord> runs(@PathVariable String taskId) {
return service.listRuns(taskId);
}
@Operation(summary = "列出变更包执行证据", description = "按变更包过滤本地 smoke/apply 结构化结果")
@GetMapping("/tasks/{taskId}/change-sets/{changeSetId}/runs")
public List<AiRunRecord> runs(@PathVariable String taskId, @PathVariable String changeSetId) {
return service.listRuns(taskId, changeSetId);
}
@Operation(summary = "生成线上人工部署包", description = "输出 manifest、SQL 草案、回滚 SQL 和本地执行证据;不连接线上环境执行")
@PostMapping("/tasks/{taskId}/change-sets/{changeSetId}/deployment-package")
public AiDeploymentPackage deploymentPackage(@PathVariable String taskId, @PathVariable String changeSetId) {
return service.createDeploymentPackage(taskId, changeSetId);
}
@Operation(summary = "生成自动修复计划", description = "读取最近失败的自动开发/本地应用/smoke 证据,输出结构化修复动作并写入 run history")
@PostMapping("/tasks/{taskId}/change-sets/{changeSetId}/repair-plan")
public AiRepairPlan repairPlan(@PathVariable String taskId, @PathVariable String changeSetId) {
return service.createRepairPlan(taskId, changeSetId);
}
@Operation(summary = "执行自动修复并重跑本地门禁", description = "仅执行 repair-plan 中标记 automated=true 的动作;存在人工动作时阻断")
@PostMapping("/tasks/{taskId}/change-sets/{changeSetId}/repair-execution")
public AiRepairExecution executeRepairPlan(@PathVariable String taskId,
@PathVariable String changeSetId,
@RequestBody(required = false) AiRepairExecutionRequest req) {
return service.executeRepairPlan(taskId, changeSetId, req == null ? null : req.baseUrl());
}
@Operation(summary = "列出任务审计日志")
@GetMapping("/tasks/{taskId}/audit")
public List<AiAuditEntry> audit(@PathVariable String taskId) {
return service.listAudit(taskId);
}
@Operation(summary = "校验任意 amis schema", description = "AI 生成 schema 的第一道闸;后续仍需渲染冒烟")
@PostMapping("/tools/validate-schema")
public Map<String, Object> validateSchema(@RequestBody JsonNode schema) {
return service.validateSchema(schema);
}
public record CreateTaskRequest(String objective) {
}
public record CreateDraftRequest(
String artifactType,
String targetId,
JsonNode payload,
Map<String, Object> metadata) {
}
public record SmokeRunRequest(String baseUrl) {
}
}

View File

@@ -0,0 +1,68 @@
-- ============================================================================
-- eip4-platform P5 AI Agent 运行态自举 schema —— bootstrap-ai-agent.sql
-- ----------------------------------------------------------------------------
-- 用途:在本地/CI 库上保存 Agent 开发任务、草稿产物、待人审变更包、执行证据和审计日志。
--
-- 纪律:可重复执行(CREATE TABLE IF NOT EXISTS / CREATE INDEX IF NOT EXISTS);
-- 只保存 AI 运行态和草稿,不直接写 SYS_PAGE_SCHEMA / SYS_ENTITY / 服务流等生产元数据。
-- 生产脚本副本见 docs/sql/SYS_AI_AGENT.sql;P5 引入 Flyway 后可原样迁入 migration。
-- ============================================================================
CREATE TABLE IF NOT EXISTS sys_ai_task (
task_id character varying(64) NOT NULL,
objective text NOT NULL,
status character varying(32) NOT NULL,
plan_json jsonb NOT NULL,
created_at bigint NOT NULL,
updated_at bigint NOT NULL,
CONSTRAINT pk_sys_ai_task PRIMARY KEY (task_id)
);
CREATE TABLE IF NOT EXISTS sys_ai_draft (
draft_id character varying(64) NOT NULL,
task_id character varying(64) NOT NULL,
artifact_type character varying(32) NOT NULL,
target_id character varying(128) NOT NULL,
payload_json jsonb NOT NULL,
gates_json jsonb NOT NULL,
metadata_json jsonb NOT NULL,
created_at bigint NOT NULL,
CONSTRAINT pk_sys_ai_draft PRIMARY KEY (draft_id)
);
CREATE TABLE IF NOT EXISTS sys_ai_change_set (
change_set_id character varying(64) NOT NULL,
task_id character varying(64) NOT NULL,
status character varying(32) NOT NULL,
draft_ids_json jsonb NOT NULL,
summary_json jsonb NOT NULL,
created_at bigint NOT NULL,
CONSTRAINT pk_sys_ai_change_set PRIMARY KEY (change_set_id)
);
CREATE TABLE IF NOT EXISTS sys_ai_run (
run_id character varying(64) NOT NULL,
task_id character varying(64) NOT NULL,
change_set_id character varying(64) NOT NULL,
run_type character varying(32) NOT NULL,
status character varying(32) NOT NULL,
payload_json jsonb NOT NULL,
created_at bigint NOT NULL,
CONSTRAINT pk_sys_ai_run PRIMARY KEY (run_id)
);
CREATE TABLE IF NOT EXISTS sys_ai_audit_log (
audit_id character varying(64) NOT NULL,
task_id character varying(64) NOT NULL,
action character varying(96) NOT NULL,
actor character varying(64) NOT NULL,
details_json jsonb NOT NULL,
created_at bigint NOT NULL,
CONSTRAINT pk_sys_ai_audit_log PRIMARY KEY (audit_id)
);
CREATE INDEX IF NOT EXISTS idx_sys_ai_draft_task ON sys_ai_draft (task_id, created_at);
CREATE INDEX IF NOT EXISTS idx_sys_ai_change_set_task ON sys_ai_change_set (task_id, created_at);
CREATE INDEX IF NOT EXISTS idx_sys_ai_run_task ON sys_ai_run (task_id, created_at);
CREATE INDEX IF NOT EXISTS idx_sys_ai_run_change_set ON sys_ai_run (change_set_id, created_at);
CREATE INDEX IF NOT EXISTS idx_sys_ai_audit_log_task ON sys_ai_audit_log (task_id, created_at);

View File

@@ -0,0 +1,689 @@
package com.eip4.platform.ai.service;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.web.server.ResponseStatusException;
import com.eip4.platform.ai.model.AiAutoDevelopmentRequest;
import com.eip4.platform.ai.model.AiArtifactType;
import com.eip4.platform.ai.model.AiFeatureField;
import com.eip4.platform.ai.model.AiFeatureRequest;
import com.eip4.platform.ai.model.AiRepairDraftPatch;
import com.eip4.platform.ai.store.InMemoryAiAgentStore;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
class AiAgentServiceTest {
private static final ObjectMapper MAPPER = new ObjectMapper();
@Test
@DisplayName("创建任务后保存有效页面草稿并生成待人审变更包")
void createTaskDraftAndChangeSet() throws Exception {
AiAgentService service = newService();
var task = service.createTask("新增合同类型维护功能");
JsonNode page = MAPPER.readTree("""
{"type":"page","title":"合同类型维护","body":{"type":"tpl","tpl":"ok"}}
""");
var draft = service.addDraft(task.id(), "PAGE_SCHEMA", "contract-type-page", page, Map.of("source", "test"));
assertTrue(draft.passed());
assertEquals(1, service.listDrafts(task.id()).size());
var changeSet = service.createChangeSet(task.id());
assertEquals("READY_FOR_REVIEW", changeSet.status());
assertEquals(1, changeSet.draftIds().size());
assertEquals(1, service.listChangeSets(task.id()).size());
assertEquals(3, service.listAudit(task.id()).size());
}
@Test
@DisplayName("无效 schema 草稿会阻止生成变更包")
void invalidSchemaBlocksChangeSet() throws Exception {
AiAgentService service = newService();
var task = service.createTask("生成坏页面");
JsonNode invalid = MAPPER.readTree("\"not-object\"");
var draft = service.addDraft(task.id(), "PAGE_SCHEMA", "bad", invalid, null);
assertFalse(draft.passed());
ResponseStatusException ex = assertThrows(ResponseStatusException.class,
() -> service.createChangeSet(task.id()));
assertEquals(409, ex.getStatusCode().value());
}
@Test
@DisplayName("不允许空目标或未知产物类型")
void validatesInputs() {
AiAgentService service = newService();
assertThrows(ResponseStatusException.class, () -> service.createTask(" "));
var task = service.createTask("合法任务");
JsonNode payload = MAPPER.createObjectNode().put("x", 1);
ResponseStatusException blankTarget = assertThrows(ResponseStatusException.class,
() -> service.addDraft(task.id(), "CODE", " ", payload, null));
assertEquals(400, blankTarget.getStatusCode().value());
ResponseStatusException ex = assertThrows(ResponseStatusException.class,
() -> service.addDraft(task.id(), "UNKNOWN", "x", payload, null));
assertEquals(400, ex.getStatusCode().value());
}
@Test
@DisplayName("自动开发功能:生成实体/页面/服务流/菜单/测试草稿并创建待人审变更包")
void developFeatureCreatesFullDraftSet() {
AiAgentService service = newService();
var result = service.developFeature(contractTypeFeature());
assertEquals(5, result.drafts().size());
assertTrue(result.drafts().stream().allMatch(d -> d.passed()), "自动生成草稿必须全部过基础门禁");
assertEquals("READY_FOR_REVIEW", result.changeSet().status());
assertEquals(5, result.changeSet().draftIds().size());
assertEquals(5, service.listDrafts(result.task().id()).size());
var plan = service.createReleasePlan(result.task().id(), result.changeSet().id());
assertTrue(plan.requiresHumanApproval());
assertEquals(5, plan.steps().size());
assertEquals("ENTITY", plan.steps().get(0).artifactType().name());
assertEquals("TEST", plan.steps().get(4).artifactType().name());
assertEquals("READY_FOR_LOCAL_APPLY", plan.status());
var smoke = service.runLocalSmoke(result.task().id(), result.changeSet().id(), "http://localhost:8084");
assertTrue(smoke.passed());
assertEquals("PASSED", smoke.status());
assertEquals(4, smoke.results().size());
assertEquals(1, service.listRuns(result.task().id(), result.changeSet().id()).size());
var apply = service.applyLocalRelease(result.task().id(), result.changeSet().id(), "http://localhost:8084");
assertTrue(apply.passed());
assertEquals("PASSED", apply.status());
assertEquals(4, apply.steps().size());
assertEquals("PASSED", apply.smokeRun().status());
assertEquals(3, service.listRuns(result.task().id()).size());
var deploymentPackage = service.createDeploymentPackage(result.task().id(), result.changeSet().id());
assertEquals("READY_FOR_HUMAN_REVIEW", deploymentPackage.status());
assertTrue(deploymentPackage.requiresHumanApproval());
assertTrue(deploymentPackage.sqlStatements().stream().anyMatch(sql -> sql.contains("sys_page_schema")));
assertTrue(deploymentPackage.sqlStatements().stream().anyMatch(sql -> sql.contains("sys_serviceflow")));
assertTrue(deploymentPackage.rollbackSqlStatements().stream().anyMatch(sql -> sql.contains("sys_serviceflow")));
assertTrue(deploymentPackage.warnings().stream().anyMatch(w -> w.contains("parentId")));
}
@Test
@DisplayName("一键自动开发会串联草稿生成、本地应用、smoke 和部署包")
void autoDevelopFeatureRunsFullPipeline() {
AiAgentService service = newService();
var run = service.autoDevelopFeature(new AiAutoDevelopmentRequest(
contractTypeFeature(), "http://localhost:8084", true, null));
assertEquals("READY_FOR_HUMAN_REVIEW", run.status());
assertEquals(run.originalChangeSetId(), run.changeSetId());
assertEquals(5, run.development().drafts().size());
assertEquals("READY_FOR_LOCAL_APPLY", run.releasePlan().status());
assertEquals("PASSED", run.applyRun().status());
assertEquals("READY_FOR_HUMAN_REVIEW", run.deploymentPackage().status());
assertTrue(run.repairExecutions().isEmpty());
assertTrue(run.messages().stream().anyMatch(m -> m.contains("parentId")));
assertEquals("READY_FOR_HUMAN_REVIEW", service.getTask(run.taskId()).status());
assertEquals(3, service.listRuns(run.taskId()).size());
assertTrue(service.listRuns(run.taskId()).stream().anyMatch(r -> "AUTO_DEVELOP".equals(r.runType())));
}
@Test
@DisplayName("一键自动开发本地应用失败时返回诊断消息并保留执行证据")
void autoDevelopFeatureReturnsDiagnosticsWhenLocalApplyFails() {
AiAgentService service = newService(new FailingLocalReleaseExecutor());
var run = service.autoDevelopFeature(new AiAutoDevelopmentRequest(
contractTypeFeature(), "http://localhost:8084", true, 0));
assertEquals("LOCAL_GATE_FAILED", run.status());
assertEquals("APPLY_FAILED", run.applyRun().status());
assertEquals("BLOCKED_PENDING_LOCAL_PASS", run.deploymentPackage().status());
assertTrue(run.repairExecutions().isEmpty());
assertTrue(run.messages().stream().anyMatch(m -> m.contains("实体接口不可用")));
assertTrue(run.messages().stream().anyMatch(m -> m.contains("LOCAL_APPLY")));
assertEquals("LOCAL_GATE_FAILED", service.getTask(run.taskId()).status());
assertEquals(2, service.listRuns(run.taskId()).size());
assertTrue(service.listRuns(run.taskId()).stream().anyMatch(r -> "AUTO_DEVELOP".equals(r.runType())));
var repairPlan = service.createRepairPlan(run.taskId(), run.changeSetId());
assertEquals("NEEDS_HUMAN_ACTION", repairPlan.status());
assertEquals(1, repairPlan.actions().size());
assertEquals("ENTITY", repairPlan.actions().get(0).artifactType());
assertEquals("REPAIR_ENTITY_METADATA_OR_LOCAL_API", repairPlan.actions().get(0).actionType());
assertTrue(repairPlan.actions().get(0).rationale().contains("实体接口不可用"));
assertEquals(3, service.listRuns(run.taskId()).size());
assertTrue(service.listRuns(run.taskId()).stream().anyMatch(r -> "REPAIR_PLAN".equals(r.runType())));
}
@Test
@DisplayName("一键自动开发默认会自动修复可恢复的本地门禁失败")
void autoDevelopFeatureAutomaticallyRepairsRecoverableSmokeFailure() {
AtomicInteger smokeCalls = new AtomicInteger();
AiSmokeRunner flakySmokeRunner = new AiSmokeRunner((method, uri, requestBody, timeout) -> {
if (smokeCalls.incrementAndGet() <= 4) {
return new AiHttpResponse(503, "temporary unavailable");
}
return new AiHttpResponse(200, "{\"status\":0}");
});
AiAgentService service = newService(new NoopLocalReleaseExecutor(), flakySmokeRunner);
var run = service.autoDevelopFeature(new AiAutoDevelopmentRequest(
contractTypeFeature(), "http://localhost:8084", true, null));
assertEquals("READY_FOR_HUMAN_REVIEW", run.status());
assertEquals(run.originalChangeSetId(), run.changeSetId());
assertEquals("PASSED", run.applyRun().status());
assertEquals(1, run.repairExecutions().size());
assertEquals("REPAIRED", run.repairExecutions().get(0).status());
assertEquals("READY_FOR_HUMAN_REVIEW", run.deploymentPackage().status());
assertTrue(run.messages().stream().anyMatch(m -> m.contains("自动修复第 1 轮结果: REPAIRED")));
assertEquals("READY_FOR_HUMAN_REVIEW", service.getTask(run.taskId()).status());
assertTrue(service.listRuns(run.taskId()).stream().anyMatch(r -> "REPAIR_EXECUTION".equals(r.runType())));
}
@Test
@DisplayName("一键自动开发关闭部署包时自动修复后只返回本地门禁通过")
void autoDevelopFeatureHonorsDeploymentPackageSwitchAfterRepair() {
AtomicInteger smokeCalls = new AtomicInteger();
AiSmokeRunner flakySmokeRunner = new AiSmokeRunner((method, uri, requestBody, timeout) -> {
if (smokeCalls.incrementAndGet() <= 4) {
return new AiHttpResponse(503, "temporary unavailable");
}
return new AiHttpResponse(200, "{\"status\":0}");
});
AiAgentService service = newService(new NoopLocalReleaseExecutor(), flakySmokeRunner);
var run = service.autoDevelopFeature(new AiAutoDevelopmentRequest(
contractTypeFeature(), "http://localhost:8084", false, null));
assertEquals("LOCAL_GATE_PASSED", run.status());
assertEquals("PASSED", run.applyRun().status());
assertEquals(1, run.repairExecutions().size());
assertEquals("REPAIRED", run.repairExecutions().get(0).status());
assertNull(run.deploymentPackage());
assertNull(run.repairExecutions().get(0).deploymentPackage());
assertEquals("LOCAL_GATE_PASSED", service.getTask(run.taskId()).status());
}
@Test
@DisplayName("自动修复执行会重试瞬时 smoke 失败并生成新部署包")
void executeRepairPlanRetriesTransientSmokeFailure() {
AtomicInteger smokeCalls = new AtomicInteger();
AiSmokeRunner flakySmokeRunner = new AiSmokeRunner((method, uri, requestBody, timeout) -> {
if (smokeCalls.incrementAndGet() <= 4) {
return new AiHttpResponse(503, "temporary unavailable");
}
return new AiHttpResponse(200, "{\"status\":0}");
});
AiAgentService service = newService(new NoopLocalReleaseExecutor(), flakySmokeRunner);
var run = service.autoDevelopFeature(new AiAutoDevelopmentRequest(
contractTypeFeature(), "http://localhost:8084", true, 0));
assertEquals("LOCAL_GATE_FAILED", run.status());
assertEquals("SMOKE_FAILED", run.applyRun().status());
var repairPlan = service.createRepairPlan(run.taskId(), run.changeSetId());
assertEquals("READY_FOR_AUTO_RETRY", repairPlan.status());
assertEquals(4, repairPlan.actions().size());
assertTrue(repairPlan.actions().stream().allMatch(a -> a.automated()));
assertTrue(repairPlan.actions().stream()
.allMatch(a -> "RETRY_TRANSIENT_SMOKE_FAILURE".equals(a.actionType())));
var execution = service.executeRepairPlan(run.taskId(), run.changeSetId(), "http://localhost:8084");
assertEquals("REPAIRED", execution.status());
assertTrue(execution.retryApplyRun().passed());
assertEquals("READY_FOR_HUMAN_REVIEW", execution.deploymentPackage().status());
assertEquals("READY_FOR_HUMAN_REVIEW", service.getTask(run.taskId()).status());
assertTrue(service.listRuns(run.taskId()).stream().anyMatch(r -> "REPAIR_EXECUTION".equals(r.runType())));
}
@Test
@DisplayName("Agent 修复执行器会生成 TEST 草稿修复 HTTP 契约偏差并重跑")
void executeRepairPlanGeneratesDraftPatchForSmokeContractMismatch() {
AiSmokeRunner contractSmokeRunner = new AiSmokeRunner((method, uri, requestBody, timeout) -> {
if ("POST".equals(method) && uri.toString().contains("/save")) {
return new AiHttpResponse(201, "{\"status\":0}");
}
return new AiHttpResponse(200, "{\"status\":0}");
});
AiAgentService service = newService(new NoopLocalReleaseExecutor(), contractSmokeRunner);
var run = service.autoDevelopFeature(new AiAutoDevelopmentRequest(
contractTypeFeature(), "http://localhost:8084", true, 0));
assertEquals("LOCAL_GATE_FAILED", run.status());
assertEquals("SMOKE_FAILED", run.applyRun().status());
var repairPlan = service.createRepairPlan(run.taskId(), run.changeSetId());
assertEquals("NEEDS_HUMAN_ACTION", repairPlan.status());
assertEquals(1, repairPlan.actions().size());
assertEquals("REPAIR_SMOKE_EXPECTATION_OR_API_CONTRACT", repairPlan.actions().get(0).actionType());
var execution = service.executeRepairPlan(run.taskId(), run.changeSetId(), "http://localhost:8084");
assertEquals("REPAIRED", execution.status());
assertEquals(1, execution.generatedDrafts().size());
assertEquals("TEST", execution.generatedDrafts().get(0).artifactType().name());
assertTrue(execution.generatedDrafts().get(0).payload().path("smokeTests").toString()
.contains("\"expectHttpStatus\":201"));
assertTrue(execution.retryApplyRun().passed());
assertEquals("READY_FOR_HUMAN_REVIEW", execution.deploymentPackage().status());
assertEquals(5, execution.repairedChangeSet().draftIds().size());
}
@Test
@DisplayName("Agent 修复执行器会生成 PAGE_SCHEMA 草稿补齐缺失 body 并重跑")
void executeRepairPlanGeneratesPageSchemaPatch() throws Exception {
AiAgentService service = newService(new PageSchemaBodyRequiredExecutor());
var task = service.createTask("修复页面 schema");
JsonNode pageWithoutBody = MAPPER.readTree("""
{"type":"page","title":"坏页面"}
""");
var pageDraft = service.addDraft(task.id(), "PAGE_SCHEMA", "bad-page", pageWithoutBody, Map.of());
assertTrue(pageDraft.passed());
JsonNode testPayload = MAPPER.readTree("""
{"smokeTests":[{"name":"page-schema","method":"GET","url":"/api/page/schema/bad-page","expectHttpStatus":200}]}
""");
service.addDraft(task.id(), "TEST", "bad-page-smoke", testPayload, Map.of());
var changeSet = service.createChangeSet(task.id());
var apply = service.applyLocalRelease(task.id(), changeSet.id(), "http://localhost:8084");
assertEquals("APPLY_FAILED", apply.status());
var repairPlan = service.createRepairPlan(task.id(), changeSet.id());
assertEquals("NEEDS_HUMAN_ACTION", repairPlan.status());
assertEquals("REPAIR_PAGE_SCHEMA_SQL_OR_SCHEMA", repairPlan.actions().get(0).actionType());
var execution = service.executeRepairPlan(task.id(), changeSet.id(), "http://localhost:8084");
assertEquals("REPAIRED", execution.status());
assertEquals(1, execution.generatedDrafts().size());
assertEquals("PAGE_SCHEMA", execution.generatedDrafts().get(0).artifactType().name());
assertTrue(execution.generatedDrafts().get(0).payload().has("body"));
assertTrue(execution.retryApplyRun().passed());
assertEquals("READY_FOR_HUMAN_REVIEW", execution.deploymentPackage().status());
assertEquals(2, execution.repairedChangeSet().draftIds().size());
}
@Test
@DisplayName("Agent 修复执行器会生成 MENU 草稿显式父级占位并重跑")
void executeRepairPlanGeneratesMenuParentPatch() throws Exception {
AiAgentService service = newService(new MenuParentRequiredExecutor());
var task = service.createTask("修复菜单挂载");
JsonNode menu = MAPPER.readTree("""
{"name":"坏菜单","viewTemplateId":"bad-page","typename":"功能菜单","seq":0}
""");
service.addDraft(task.id(), "MENU", "bad-page", menu, Map.of());
JsonNode testPayload = MAPPER.readTree("""
{"smokeTests":[{"name":"page-schema","method":"GET","url":"/api/page/schema/bad-page","expectHttpStatus":200}]}
""");
service.addDraft(task.id(), "TEST", "bad-page-smoke", testPayload, Map.of());
var changeSet = service.createChangeSet(task.id());
var apply = service.applyLocalRelease(task.id(), changeSet.id(), "http://localhost:8084");
assertEquals("APPLY_FAILED", apply.status());
var repairPlan = service.createRepairPlan(task.id(), changeSet.id());
assertEquals("NEEDS_HUMAN_ACTION", repairPlan.status());
assertEquals("SEED_MENU_ROOT_OR_SET_PARENT", repairPlan.actions().get(0).actionType());
var execution = service.executeRepairPlan(task.id(), changeSet.id(), "http://localhost:8084");
assertEquals("REPAIRED", execution.status());
assertEquals(1, execution.generatedDrafts().size());
assertEquals("MENU", execution.generatedDrafts().get(0).artifactType().name());
assertEquals("${parentMenuId}", execution.generatedDrafts().get(0).payload().path("parentId").asText());
assertTrue(execution.retryApplyRun().passed());
assertEquals("READY_FOR_HUMAN_REVIEW", execution.deploymentPackage().status());
assertTrue(execution.deploymentPackage().warnings().stream().anyMatch(w -> w.contains("parentId")));
assertEquals(2, execution.repairedChangeSet().draftIds().size());
}
@Test
@DisplayName("Agent 修复执行器会生成 SERVICEFLOW 草稿恢复 entityId 占位绑定并重跑")
void executeRepairPlanGeneratesServiceFlowEntityBindingPatch() throws Exception {
AiAgentService service = newService(new ServiceFlowEntityBindingExecutor());
var task = service.createTask("修复服务流 entityId 绑定");
JsonNode entity = MAPPER.readTree("""
{"tablename":"EIP4AI_FLOW_FIX","name":"服务流修复","attributes":[{"column":"NAME","display":"名称","type":"string","mandatory":true}]}
""");
service.addDraft(task.id(), "ENTITY", "EIP4AI_FLOW_FIX", entity, Map.of());
JsonNode serviceFlow = MAPPER.readTree("""
{"requiresEntityId":true,"flows":[{"key":"EIP4AI_FLOW_FIX_SEARCH","displayName":"查询","entityId":"wrong-entity-id","control":true,"updateable":true,"contentXml":"<flow><input entityid=\\"wrong-entity-id\\"/><transition/></flow>"}]}
""");
service.addDraft(task.id(), "SERVICEFLOW", "EIP4AI_FLOW_FIX_DEFAULT_FLOWS", serviceFlow, Map.of());
JsonNode testPayload = MAPPER.readTree("""
{"smokeTests":[{"name":"flow-search","method":"GET","url":"/api/flow/EIP4AI_FLOW_FIX_SEARCH","expectHttpStatus":200}]}
""");
service.addDraft(task.id(), "TEST", "flow-fix-smoke", testPayload, Map.of());
var changeSet = service.createChangeSet(task.id());
var apply = service.applyLocalRelease(task.id(), changeSet.id(), "http://localhost:8084");
assertEquals("APPLY_FAILED", apply.status());
var repairPlan = service.createRepairPlan(task.id(), changeSet.id());
assertEquals("NEEDS_HUMAN_ACTION", repairPlan.status());
assertEquals("RETRY_AFTER_ENTITY_ID_RESOLUTION", repairPlan.actions().get(0).actionType());
var execution = service.executeRepairPlan(task.id(), changeSet.id(), "http://localhost:8084");
assertEquals("REPAIRED", execution.status());
assertEquals(1, execution.generatedDrafts().size());
assertEquals("SERVICEFLOW", execution.generatedDrafts().get(0).artifactType().name());
assertTrue(execution.generatedDrafts().get(0).payload().toString().contains("${entityId}"));
assertTrue(execution.retryApplyRun().passed());
assertEquals("READY_FOR_HUMAN_REVIEW", execution.deploymentPackage().status());
assertEquals(3, execution.repairedChangeSet().draftIds().size());
}
@Test
@DisplayName("Agent 修复执行器会生成 ENTITY 草稿补齐发布目标并重跑")
void executeRepairPlanGeneratesEntityPublishTargetPatch() throws Exception {
AiAgentService service = newService(new EntityPublishTargetRequiredExecutor());
var task = service.createTask("修复实体发布目标");
JsonNode entity = MAPPER.readTree("""
{"tablename":"EIP4AI_ENTITY_FIX","name":"实体修复","attributes":[{"column":"NAME","display":"","type":"string","mandatory":true}]}
""");
service.addDraft(task.id(), "ENTITY", "EIP4AI_ENTITY_FIX", entity, Map.of());
JsonNode testPayload = MAPPER.readTree("""
{"smokeTests":[{"name":"entity-list","method":"GET","url":"/api/entity/EIP4AI_ENTITY_FIX/list","expectHttpStatus":200}]}
""");
service.addDraft(task.id(), "TEST", "entity-fix-smoke", testPayload, Map.of());
var changeSet = service.createChangeSet(task.id());
var apply = service.applyLocalRelease(task.id(), changeSet.id(), "http://localhost:8084");
assertEquals("APPLY_FAILED", apply.status());
var repairPlan = service.createRepairPlan(task.id(), changeSet.id());
assertEquals("NEEDS_HUMAN_ACTION", repairPlan.status());
assertEquals("REPAIR_ENTITY_METADATA_OR_LOCAL_API", repairPlan.actions().get(0).actionType());
var execution = service.executeRepairPlan(task.id(), changeSet.id(), "http://localhost:8084");
assertEquals("REPAIRED", execution.status());
assertEquals(1, execution.generatedDrafts().size());
assertEquals("ENTITY", execution.generatedDrafts().get(0).artifactType().name());
assertEquals("/api/meta/entity", execution.generatedDrafts().get(0).payload().path("publishTarget").asText());
assertEquals("NAME", execution.generatedDrafts().get(0).payload().path("attributes").get(0).path("display").asText());
assertTrue(execution.retryApplyRun().passed());
assertEquals("READY_FOR_HUMAN_REVIEW", execution.deploymentPackage().status());
assertEquals(2, execution.repairedChangeSet().draftIds().size());
}
@Test
@DisplayName("LLM 修复客户端返回草稿补丁时优先于确定性 fallback")
void executeRepairPlanUsesLlmDraftPatchBeforeDeterministicFallback() throws Exception {
AiLlmRepairClient llmClient = context -> java.util.List.of(new AiRepairDraftPatch(
AiArtifactType.ENTITY,
"EIP4AI_ENTITY_FIX",
json("""
{"publishTarget":"/api/meta/entity","tablename":"EIP4AI_ENTITY_FIX","name":"LLM实体修复","attributes":[{"column":"NAME","display":"LLM名称","type":"string","mandatory":true}]}
"""),
Map.of("source", "fake-llm")));
AiAgentService service = newService(new EntityPublishTargetRequiredExecutor(),
new AiSmokeRunner((method, uri, requestBody, timeout) -> new AiHttpResponse(200, "{\"status\":0}")),
new DeterministicAiAgentRepairExecutor(MAPPER, java.util.List.of(llmClient)));
var task = service.createTask("LLM 修复实体发布目标");
JsonNode entity = MAPPER.readTree("""
{"tablename":"EIP4AI_ENTITY_FIX","name":"实体修复","attributes":[{"column":"NAME","display":"","type":"string","mandatory":true}]}
""");
service.addDraft(task.id(), "ENTITY", "EIP4AI_ENTITY_FIX", entity, Map.of());
JsonNode testPayload = MAPPER.readTree("""
{"smokeTests":[{"name":"entity-list","method":"GET","url":"/api/entity/EIP4AI_ENTITY_FIX/list","expectHttpStatus":200}]}
""");
service.addDraft(task.id(), "TEST", "entity-fix-smoke", testPayload, Map.of());
var changeSet = service.createChangeSet(task.id());
service.applyLocalRelease(task.id(), changeSet.id(), "http://localhost:8084");
service.createRepairPlan(task.id(), changeSet.id());
var execution = service.executeRepairPlan(task.id(), changeSet.id(), "http://localhost:8084");
assertEquals("REPAIRED", execution.status());
assertEquals("LLM实体修复", execution.generatedDrafts().get(0).payload().path("name").asText());
assertEquals("fake-llm", execution.generatedDrafts().get(0).metadata().get("source"));
assertTrue(execution.retryApplyRun().passed());
}
@Test
@DisplayName("实体草稿字段非法会阻止生成变更包")
void invalidEntityDraftBlocksChangeSet() {
AiAgentService service = newService();
var task = service.createTask("坏实体");
JsonNode invalidEntity = MAPPER.createObjectNode()
.put("tablename", "bad table")
.put("name", "坏实体")
.set("attributes", MAPPER.createArrayNode()
.add(MAPPER.createObjectNode().put("column", "BAD-COL").put("type", "unknown")));
var draft = service.addDraft(task.id(), "ENTITY", "bad", invalidEntity, null);
assertFalse(draft.passed());
ResponseStatusException ex = assertThrows(ResponseStatusException.class,
() -> service.createChangeSet(task.id()));
assertEquals(409, ex.getStatusCode().value());
}
private static AiAgentService newService() {
return newService(new NoopLocalReleaseExecutor());
}
private static AiAgentService newService(AiLocalReleaseExecutor localReleaseExecutor) {
return newService(localReleaseExecutor,
new AiSmokeRunner((method, uri, requestBody, timeout) -> new AiHttpResponse(200, "{\"status\":0}")));
}
private static AiAgentService newService(AiLocalReleaseExecutor localReleaseExecutor, AiSmokeRunner smokeRunner) {
return newService(localReleaseExecutor, smokeRunner, new DeterministicAiAgentRepairExecutor(MAPPER));
}
private static AiAgentService newService(AiLocalReleaseExecutor localReleaseExecutor,
AiSmokeRunner smokeRunner,
AiAgentRepairExecutor repairExecutor) {
return new AiAgentService(new InMemoryAiAgentStore(), new AiFeatureDraftGenerator(MAPPER),
smokeRunner, localReleaseExecutor, repairExecutor, MAPPER);
}
private static AiFeatureRequest contractTypeFeature() {
return new AiFeatureRequest(
"新增合同类型维护功能",
"合同类型维护",
"EIP4AI_CONTRACT_TYPE",
"合同类型",
"eip4ai-contract-type",
"合同类型维护",
java.util.List.of(
new AiFeatureField("NAME", "名称", "string", 100, true),
new AiFeatureField("CODE", "编码", "string", 64, true),
new AiFeatureField("ENABLED", "启用", "boolean", null, false)));
}
private static JsonNode json(String text) {
try {
return MAPPER.readTree(text);
} catch (Exception ex) {
throw new IllegalArgumentException(ex);
}
}
private static class NoopLocalReleaseExecutor extends AiLocalReleaseExecutor {
NoopLocalReleaseExecutor() {
super(org.mockito.Mockito.mock(org.springframework.jdbc.core.JdbcTemplate.class),
(method, uri, requestBody, timeout) -> new AiHttpResponse(200, "{\"status\":0}"), MAPPER);
}
@Override
public java.util.List<com.eip4.platform.ai.model.AiApplyStepResult> apply(
String baseUrl, java.util.List<com.eip4.platform.ai.model.AiDraft> drafts) {
return drafts.stream()
.filter(d -> d.artifactType() != com.eip4.platform.ai.model.AiArtifactType.TEST)
.map(d -> {
Map<String, Object> details = switch (d.artifactType()) {
case ENTITY -> Map.of("entityId", "e-test-entity-id", "tableName", d.targetId());
case SERVICEFLOW -> Map.of("flowCount", 5, "entityId", "e-test-entity-id");
case PAGE_SCHEMA -> Map.of("templateId", d.targetId(), "etag", "test-etag");
case MENU -> Map.of("menuId", "m-test-menu-id");
case CODE, TEST -> Map.of();
};
return new com.eip4.platform.ai.model.AiApplyStepResult(
"apply-" + d.id(), d.artifactType(), d.targetId(), "APPLIED", "ok", details);
})
.toList();
}
}
private static class FailingLocalReleaseExecutor extends AiLocalReleaseExecutor {
FailingLocalReleaseExecutor() {
super(org.mockito.Mockito.mock(org.springframework.jdbc.core.JdbcTemplate.class),
(method, uri, requestBody, timeout) -> new AiHttpResponse(500, "{\"status\":1}"), MAPPER);
}
@Override
public java.util.List<com.eip4.platform.ai.model.AiApplyStepResult> apply(
String baseUrl, java.util.List<com.eip4.platform.ai.model.AiDraft> drafts) {
var first = drafts.get(0);
return java.util.List.of(new com.eip4.platform.ai.model.AiApplyStepResult(
"apply-1", first.artifactType(), first.targetId(), "FAILED",
"实体接口不可用", Map.of()));
}
}
private static class PageSchemaBodyRequiredExecutor extends AiLocalReleaseExecutor {
PageSchemaBodyRequiredExecutor() {
super(org.mockito.Mockito.mock(org.springframework.jdbc.core.JdbcTemplate.class),
(method, uri, requestBody, timeout) -> new AiHttpResponse(200, "{\"status\":0}"), MAPPER);
}
@Override
public java.util.List<com.eip4.platform.ai.model.AiApplyStepResult> apply(
String baseUrl, java.util.List<com.eip4.platform.ai.model.AiDraft> drafts) {
java.util.List<com.eip4.platform.ai.model.AiApplyStepResult> out = new java.util.ArrayList<>();
int index = 1;
for (var draft : drafts) {
if (draft.artifactType() == com.eip4.platform.ai.model.AiArtifactType.TEST) {
continue;
}
if (draft.artifactType() == com.eip4.platform.ai.model.AiArtifactType.PAGE_SCHEMA
&& !draft.payload().has("body")) {
out.add(new com.eip4.platform.ai.model.AiApplyStepResult(
"apply-" + index, draft.artifactType(), draft.targetId(), "FAILED",
"页面 schema 缺少 body", Map.of()));
return out;
}
out.add(new com.eip4.platform.ai.model.AiApplyStepResult(
"apply-" + index, draft.artifactType(), draft.targetId(), "APPLIED", "ok", Map.of()));
index++;
}
return out;
}
}
private static class MenuParentRequiredExecutor extends AiLocalReleaseExecutor {
MenuParentRequiredExecutor() {
super(org.mockito.Mockito.mock(org.springframework.jdbc.core.JdbcTemplate.class),
(method, uri, requestBody, timeout) -> new AiHttpResponse(200, "{\"status\":0}"), MAPPER);
}
@Override
public java.util.List<com.eip4.platform.ai.model.AiApplyStepResult> apply(
String baseUrl, java.util.List<com.eip4.platform.ai.model.AiDraft> drafts) {
java.util.List<com.eip4.platform.ai.model.AiApplyStepResult> out = new java.util.ArrayList<>();
int index = 1;
for (var draft : drafts) {
if (draft.artifactType() == com.eip4.platform.ai.model.AiArtifactType.TEST) {
continue;
}
if (draft.artifactType() == com.eip4.platform.ai.model.AiArtifactType.MENU
&& draft.payload().path("parentId").asText("").isBlank()) {
out.add(new com.eip4.platform.ai.model.AiApplyStepResult(
"apply-" + index, draft.artifactType(), draft.targetId(), "FAILED",
"缺少 sys_menu_root,不能自动挂载菜单", Map.of()));
return out;
}
out.add(new com.eip4.platform.ai.model.AiApplyStepResult(
"apply-" + index, draft.artifactType(), draft.targetId(), "APPLIED", "ok", Map.of()));
index++;
}
return out;
}
}
private static class ServiceFlowEntityBindingExecutor extends AiLocalReleaseExecutor {
ServiceFlowEntityBindingExecutor() {
super(org.mockito.Mockito.mock(org.springframework.jdbc.core.JdbcTemplate.class),
(method, uri, requestBody, timeout) -> new AiHttpResponse(200, "{\"status\":0}"), MAPPER);
}
@Override
public java.util.List<com.eip4.platform.ai.model.AiApplyStepResult> apply(
String baseUrl, java.util.List<com.eip4.platform.ai.model.AiDraft> drafts) {
java.util.List<com.eip4.platform.ai.model.AiApplyStepResult> out = new java.util.ArrayList<>();
int index = 1;
for (var draft : drafts) {
if (draft.artifactType() == com.eip4.platform.ai.model.AiArtifactType.TEST) {
continue;
}
if (draft.artifactType() == com.eip4.platform.ai.model.AiArtifactType.SERVICEFLOW
&& !draft.payload().toString().contains("${entityId}")) {
out.add(new com.eip4.platform.ai.model.AiApplyStepResult(
"apply-" + index, draft.artifactType(), draft.targetId(), "FAILED",
"服务流 contentXml 缺少 ${entityId} 占位", Map.of()));
return out;
}
out.add(new com.eip4.platform.ai.model.AiApplyStepResult(
"apply-" + index, draft.artifactType(), draft.targetId(), "APPLIED", "ok", Map.of()));
index++;
}
return out;
}
}
private static class EntityPublishTargetRequiredExecutor extends AiLocalReleaseExecutor {
EntityPublishTargetRequiredExecutor() {
super(org.mockito.Mockito.mock(org.springframework.jdbc.core.JdbcTemplate.class),
(method, uri, requestBody, timeout) -> new AiHttpResponse(200, "{\"status\":0}"), MAPPER);
}
@Override
public java.util.List<com.eip4.platform.ai.model.AiApplyStepResult> apply(
String baseUrl, java.util.List<com.eip4.platform.ai.model.AiDraft> drafts) {
java.util.List<com.eip4.platform.ai.model.AiApplyStepResult> out = new java.util.ArrayList<>();
int index = 1;
for (var draft : drafts) {
if (draft.artifactType() == com.eip4.platform.ai.model.AiArtifactType.TEST) {
continue;
}
if (draft.artifactType() == com.eip4.platform.ai.model.AiArtifactType.ENTITY
&& !"/api/meta/entity".equals(draft.payload().path("publishTarget").asText(""))) {
out.add(new com.eip4.platform.ai.model.AiApplyStepResult(
"apply-" + index, draft.artifactType(), draft.targetId(), "FAILED",
"实体草稿缺少 publishTarget=/api/meta/entity", Map.of()));
return out;
}
out.add(new com.eip4.platform.ai.model.AiApplyStepResult(
"apply-" + index, draft.artifactType(), draft.targetId(), "APPLIED", "ok",
draft.artifactType() == com.eip4.platform.ai.model.AiArtifactType.ENTITY
? Map.of("entityId", "e-test-entity-id") : Map.of()));
index++;
}
return out;
}
}
}

View File

@@ -0,0 +1,71 @@
package com.eip4.platform.ai.service;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.List;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import com.eip4.platform.ai.model.AiArtifactType;
import com.eip4.platform.ai.model.AiFeatureField;
import com.eip4.platform.ai.model.AiFeatureRequest;
import com.fasterxml.jackson.databind.ObjectMapper;
class AiFeatureDraftGeneratorTest {
private static final ObjectMapper MAPPER = new ObjectMapper();
@Test
@DisplayName("根据功能规格生成 5 类草稿")
void generatesFeatureDrafts() {
AiFeatureDraftGenerator generator = new AiFeatureDraftGenerator(MAPPER);
var drafts = generator.generate(new AiFeatureRequest(
"新增合同类型维护",
"合同类型维护",
"EIP4AI_CONTRACT_TYPE",
"合同类型",
"eip4ai-contract-type",
"合同类型维护",
List.of(new AiFeatureField("NAME", "名称", "string", 100, true))));
assertEquals(5, drafts.size());
assertTrue(drafts.stream().anyMatch(d -> d.artifactType() == AiArtifactType.ENTITY));
assertTrue(drafts.stream().anyMatch(d -> d.artifactType() == AiArtifactType.PAGE_SCHEMA));
assertTrue(drafts.stream().anyMatch(d -> d.artifactType() == AiArtifactType.SERVICEFLOW));
assertTrue(drafts.stream().anyMatch(d -> d.artifactType() == AiArtifactType.MENU));
assertTrue(drafts.stream().anyMatch(d -> d.artifactType() == AiArtifactType.TEST));
var serviceFlow = drafts.stream().filter(d -> d.artifactType() == AiArtifactType.SERVICEFLOW)
.findFirst().orElseThrow();
assertEquals(5, serviceFlow.payload().path("flows").size());
assertFalse(serviceFlow.payload().path("flows").get(0).path("contentXml").asText().isBlank());
var test = drafts.stream().filter(d -> d.artifactType() == AiArtifactType.TEST)
.findFirst().orElseThrow();
assertTrue(test.payload().path("smokeTests").get(3).has("requestBody"));
}
@Test
@DisplayName("功能规格缺表名和字段时生成安全默认值")
void fillsSafeDefaults() {
AiFeatureDraftGenerator generator = new AiFeatureDraftGenerator(MAPPER);
var drafts = generator.generate(new AiFeatureRequest(
"新增客户反馈登记",
"客户反馈登记",
null,
null,
null,
null,
null));
var entity = drafts.stream().filter(d -> d.artifactType() == AiArtifactType.ENTITY)
.findFirst().orElseThrow();
assertTrue(entity.targetId().startsWith("EIP4AI_"));
assertNotNull(entity.payload().path("attributes").get(0));
assertEquals("NAME", entity.payload().path("attributes").get(0).path("column").asText());
}
}

View File

@@ -0,0 +1,128 @@
package com.eip4.platform.ai.service;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.atLeastOnce;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.mockingDetails;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.jdbc.core.JdbcTemplate;
import com.eip4.platform.ai.model.AiArtifactType;
import com.eip4.platform.ai.model.AiDraft;
import com.eip4.platform.ai.model.AiFeatureField;
import com.eip4.platform.ai.model.AiFeatureRequest;
import com.eip4.platform.ai.model.AiGeneratedDraft;
import com.eip4.platform.ai.model.AiGateResult;
import com.fasterxml.jackson.databind.ObjectMapper;
class AiLocalReleaseExecutorTest {
private static final ObjectMapper MAPPER = new ObjectMapper();
@Test
@DisplayName("本地应用按实体→服务流→页面→菜单写入")
void appliesGeneratedDrafts() {
JdbcTemplate jdbc = mock(JdbcTemplate.class);
when(jdbc.queryForObject(anyString(), eq(Boolean.class), any())).thenReturn(true);
when(jdbc.queryForList(anyString(), eq(String.class))).thenReturn(List.of("ROOT"));
when(jdbc.queryForList(anyString(), eq(String.class), any())).thenReturn(List.of());
when(jdbc.update(anyString(), org.mockito.ArgumentMatchers.<Object>any())).thenReturn(1);
when(jdbc.update(anyString(), org.mockito.ArgumentMatchers.<Object[]>any())).thenReturn(1);
AiLocalReleaseExecutor executor = new AiLocalReleaseExecutor(jdbc,
(method, uri, requestBody, timeout) -> new AiHttpResponse(200,
"{\"status\":0,\"data\":{\"entityId\":\"e1000000-0000-0000-0000-00000000ai01\"}}"),
MAPPER);
AiFeatureDraftGenerator generator = new AiFeatureDraftGenerator(MAPPER);
List<AiDraft> drafts = toDrafts(generator.generate(new AiFeatureRequest(
"新增合同类型维护", "合同类型维护", "EIP4AI_CONTRACT_TYPE", "合同类型",
"eip4ai-contract-type", "合同类型维护",
List.of(new AiFeatureField("NAME", "名称", "string", 100, true)))));
var results = executor.apply("http://localhost:8084", drafts);
assertEquals(4, results.size());
assertTrue(results.stream().allMatch(r -> "APPLIED".equals(r.status())));
assertEquals("ENTITY", results.get(0).artifactType().name());
assertEquals("SERVICEFLOW", results.get(1).artifactType().name());
assertEquals("PAGE_SCHEMA", results.get(2).artifactType().name());
assertEquals("MENU", results.get(3).artifactType().name());
assertTrue(hasUpdateSql(jdbc, "sys_serviceflow"));
assertTrue(hasUpdateSql(jdbc, "sys_page_schema"));
assertTrue(hasUpdateSql(jdbc, "sys_menu"));
}
@Test
@DisplayName("实体已存在时复用本地 entityId 并视为幂等成功")
void reusesExistingEntityId() {
JdbcTemplate jdbc = mock(JdbcTemplate.class);
when(jdbc.queryForList(anyString(), eq(String.class), eq("EIP4AI_EXISTING")))
.thenReturn(List.of("entity-existing-001"));
AiLocalReleaseExecutor executor = new AiLocalReleaseExecutor(jdbc,
(method, uri, requestBody, timeout) -> new AiHttpResponse(200,
"{\"status\":1,\"msg\":\"实体已存在: EIP4AI_EXISTING\"}"),
MAPPER);
AiDraft draft = new AiDraft("d-entity", "t-1", AiArtifactType.ENTITY, "EIP4AI_EXISTING",
MAPPER.createObjectNode().put("tablename", "EIP4AI_EXISTING"),
1L, List.of(new AiGateResult("ok", true, List.of())), Map.of());
var results = executor.apply("http://localhost:8084", List.of(draft));
assertEquals(1, results.size());
assertEquals("APPLIED", results.get(0).status());
assertEquals("entity-existing-001", results.get(0).details().get("entityId"));
assertEquals(true, results.get(0).details().get("idempotent"));
}
@Test
@DisplayName("本地库缺 sys_menu 时菜单发布跳过但不阻断 apply")
void skipsMenuWhenLocalSchemaDoesNotHaveMenuTable() {
JdbcTemplate jdbc = mock(JdbcTemplate.class);
when(jdbc.queryForObject(anyString(), eq(Boolean.class), any())).thenReturn(false);
when(jdbc.update(anyString(), org.mockito.ArgumentMatchers.<Object[]>any())).thenReturn(1);
AiLocalReleaseExecutor executor = new AiLocalReleaseExecutor(jdbc,
(method, uri, requestBody, timeout) -> new AiHttpResponse(200,
"{\"status\":0,\"data\":{\"entityId\":\"e1000000-0000-0000-0000-00000000ai01\"}}"),
MAPPER);
AiFeatureDraftGenerator generator = new AiFeatureDraftGenerator(MAPPER);
List<AiDraft> drafts = toDrafts(generator.generate(new AiFeatureRequest(
"新增合同类型维护", "合同类型维护", "EIP4AI_CONTRACT_TYPE", "合同类型",
"eip4ai-contract-type", "合同类型维护",
List.of(new AiFeatureField("NAME", "名称", "string", 100, true)))));
var results = executor.apply("http://localhost:8084", drafts);
assertEquals(4, results.size());
assertEquals("SKIPPED", results.get(3).status());
assertTrue(results.get(3).message().contains("sys_menu"));
}
private static List<AiDraft> toDrafts(List<AiGeneratedDraft> generated) {
List<AiDraft> drafts = new ArrayList<>();
for (AiGeneratedDraft g : generated) {
drafts.add(new AiDraft("d-" + drafts.size(), "t-1", g.artifactType(), g.targetId(), g.payload(),
1L, List.of(new AiGateResult("ok", true, List.of())), Map.of()));
}
return drafts;
}
private static boolean hasUpdateSql(JdbcTemplate jdbc, String token) {
return mockingDetails(jdbc).getInvocations().stream()
.filter(i -> "update".equals(i.getMethod().getName()))
.anyMatch(i -> i.getArguments().length > 0 && String.valueOf(i.getArguments()[0]).contains(token));
}
}

View File

@@ -0,0 +1,76 @@
package com.eip4.platform.ai.service;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.net.URI;
import java.util.ArrayList;
import java.util.List;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.web.server.ResponseStatusException;
import com.fasterxml.jackson.databind.ObjectMapper;
class AiSmokeRunnerTest {
private static final ObjectMapper MAPPER = new ObjectMapper();
@Test
@DisplayName("运行 smokeTests 并返回逐条结果")
void runsSmokeTests() throws Exception {
List<URI> called = new ArrayList<>();
AiSmokeRunner runner = new AiSmokeRunner((method, uri, requestBody, timeout) -> {
called.add(uri);
return new AiHttpResponse(uri.getPath().endsWith("/ok") ? 200 : 500, "{\"ok\":true}");
});
var run = runner.run("ait-1", "aics-1", "http://localhost:8084", MAPPER.readTree("""
{"smokeTests":[
{"name":"ok","method":"GET","url":"/api/ok","expectHttpStatus":200},
{"name":"bad","method":"GET","url":"/api/bad","expectHttpStatus":200}
]}
"""));
assertFalse(run.passed());
assertEquals("FAILED", run.status());
assertEquals(2, run.results().size());
assertTrue(run.results().get(0).passed());
assertFalse(run.results().get(1).passed());
assertEquals("http://localhost:8084/api/ok", called.get(0).toString());
}
@Test
@DisplayName("HTTP 200 但响应 JSON status 非 0 时判失败")
void failsOnBusinessStatusError() throws Exception {
AiSmokeRunner runner = new AiSmokeRunner((method, uri, requestBody, timeout) ->
new AiHttpResponse(200, "{\"status\":1,\"msg\":\"业务失败\"}"));
var run = runner.run("ait-1", "aics-1", "http://localhost:8084", MAPPER.readTree("""
{"smokeTests":[
{"name":"biz","method":"GET","url":"/api/biz","expectHttpStatus":200}
]}
"""));
assertFalse(run.passed());
assertEquals("FAILED", run.status());
assertFalse(run.results().get(0).passed());
assertTrue(run.results().get(0).error().contains("status=1"));
}
@Test
@DisplayName("smoke runner 拒绝非本机 baseUrl")
void rejectsRemoteBaseUrl() throws Exception {
AiSmokeRunner runner = new AiSmokeRunner((method, uri, requestBody, timeout) -> new AiHttpResponse(200, ""));
ResponseStatusException ex = assertThrows(ResponseStatusException.class,
() -> runner.run("ait-1", "aics-1", "https://example.com", MAPPER.readTree("""
{"smokeTests":[{"name":"x","method":"GET","url":"/api/x","expectHttpStatus":200}]}
""")));
assertEquals(400, ex.getStatusCode().value());
}
}

View File

@@ -0,0 +1,37 @@
package com.eip4.platform.ai.service;
import static org.assertj.core.api.Assertions.assertThat;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.runner.ApplicationContextRunner;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import com.eip4.platform.ai.store.AiAgentStore;
import com.eip4.platform.ai.web.AiAgentController;
import com.fasterxml.jackson.databind.ObjectMapper;
class AiSpringWiringTest {
private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
.withUserConfiguration(AiModuleConfiguration.class)
.withBean(ObjectMapper.class, ObjectMapper::new)
.withBean(JdbcTemplate.class, () -> org.mockito.Mockito.mock(JdbcTemplate.class));
@Test
void aiModuleComponentsWireInSpringContext() {
contextRunner.run(context -> {
assertThat(context).hasSingleBean(AiAgentController.class);
assertThat(context).hasSingleBean(AiAgentService.class);
assertThat(context).hasSingleBean(AiSmokeRunner.class);
assertThat(context).hasSingleBean(AiSmokeHttpClient.class);
assertThat(context).hasSingleBean(AiAgentStore.class);
});
}
@Configuration
@ComponentScan("com.eip4.platform.ai")
static class AiModuleConfiguration {
}
}

View File

@@ -0,0 +1,113 @@
package com.eip4.platform.ai.service;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.http.HttpClient;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicReference;
import com.eip4.platform.ai.model.AiAgentRepairContext;
import com.eip4.platform.ai.model.AiArtifactType;
import com.eip4.platform.ai.model.AiChangeSet;
import com.eip4.platform.ai.model.AiDraft;
import com.eip4.platform.ai.model.AiGateResult;
import com.eip4.platform.ai.model.AiRepairAction;
import com.eip4.platform.ai.model.AiRepairDraftPatch;
import com.eip4.platform.ai.model.AiRepairPlan;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.sun.net.httpserver.HttpServer;
import org.junit.jupiter.api.Test;
class HttpAiLlmRepairClientTest {
private static final ObjectMapper MAPPER = new ObjectMapper();
@Test
void sendsRepairContextAndParsesDraftPatches() throws Exception {
AtomicReference<String> authorization = new AtomicReference<>();
AtomicReference<String> requestBody = new AtomicReference<>();
HttpServer server = startServer(200, authorization, requestBody, """
{
"draftPatches": [
{
"artifactType": "PAGE_SCHEMA",
"targetId": "customer-page",
"payload": {"type":"page","title":"客户管理","body":[]},
"metadata": {"source":"llm-repair"}
}
]
}
""");
try {
String endpoint = "http://127.0.0.1:" + server.getAddress().getPort() + "/repair";
HttpAiLlmRepairClient client = new HttpAiLlmRepairClient(
MAPPER, HttpClient.newHttpClient(), endpoint, "secret-token", "repair-model");
List<AiRepairDraftPatch> patches = client.repair(context());
assertEquals("Bearer secret-token", authorization.get());
assertTrue(requestBody.get().contains("\"model\":\"repair-model\""));
assertTrue(requestBody.get().contains("\"taskId\":\"ait-1\""));
assertTrue(requestBody.get().contains("\"responseField\":\"draftPatches\""));
assertEquals(1, patches.size());
assertEquals(AiArtifactType.PAGE_SCHEMA, patches.get(0).artifactType());
assertEquals("customer-page", patches.get(0).targetId());
assertEquals("llm-repair", patches.get(0).metadata().get("source"));
} finally {
server.stop(0);
}
}
@Test
void returnsEmptyPatchesWhenProviderFails() throws Exception {
HttpServer server = startServer(500, new AtomicReference<>(), new AtomicReference<>(), "{}");
try {
String endpoint = "http://127.0.0.1:" + server.getAddress().getPort() + "/repair";
HttpAiLlmRepairClient client = new HttpAiLlmRepairClient(
MAPPER, HttpClient.newHttpClient(), endpoint, "", "repair-model");
assertTrue(client.repair(context()).isEmpty());
} finally {
server.stop(0);
}
}
private static HttpServer startServer(int statusCode,
AtomicReference<String> authorization,
AtomicReference<String> requestBody,
String response) throws IOException {
HttpServer server = HttpServer.create(new InetSocketAddress("127.0.0.1", 0), 0);
server.createContext("/repair", exchange -> {
authorization.set(exchange.getRequestHeaders().getFirst("Authorization"));
requestBody.set(new String(exchange.getRequestBody().readAllBytes(), StandardCharsets.UTF_8));
byte[] bytes = response.getBytes(StandardCharsets.UTF_8);
exchange.getResponseHeaders().add("Content-Type", "application/json");
exchange.sendResponseHeaders(statusCode, bytes.length);
exchange.getResponseBody().write(bytes);
exchange.close();
});
server.start();
return server;
}
private static AiAgentRepairContext context() throws Exception {
AiRepairPlan plan = new AiRepairPlan("ait-1", "aics-1", "run-1", "READY_FOR_AUTO_RETRY",
100L,
List.of(new AiRepairAction("repair-1", "LOCAL_APPLY", "REPAIR_PAGE_SCHEMA_SQL_OR_SCHEMA",
"PAGE_SCHEMA", "customer-page", false, "页面 schema 缺少 body", Map.of())),
List.of("需要修复页面 schema"));
AiDraft draft = new AiDraft("aid-1", "ait-1", AiArtifactType.PAGE_SCHEMA, "customer-page",
MAPPER.readTree("{\"type\":\"page\",\"title\":\"客户管理\"}"),
90L,
List.of(new AiGateResult("schema", true, List.of())),
Map.of("source", "test"));
return new AiAgentRepairContext("ait-1", new AiChangeSet("aics-1", "ait-1",
"READY_FOR_REVIEW", 80L, List.of("aid-1"), Map.of()).id(), plan, List.of(draft));
}
}

View File

@@ -0,0 +1,27 @@
package com.eip4.platform.ai.store;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.nio.charset.StandardCharsets;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.util.StreamUtils;
class AiAgentDdlTest {
@Test
@DisplayName("AI Agent bootstrap DDL 包含运行态平台表")
void bootstrapDdlDeclaresTables() throws Exception {
String ddl = StreamUtils.copyToString(
getClass().getResourceAsStream("/bootstrap/bootstrap-ai-agent.sql"),
StandardCharsets.UTF_8);
assertTrue(ddl.contains("CREATE TABLE IF NOT EXISTS sys_ai_task"));
assertTrue(ddl.contains("CREATE TABLE IF NOT EXISTS sys_ai_draft"));
assertTrue(ddl.contains("CREATE TABLE IF NOT EXISTS sys_ai_change_set"));
assertTrue(ddl.contains("CREATE TABLE IF NOT EXISTS sys_ai_run"));
assertTrue(ddl.contains("CREATE TABLE IF NOT EXISTS sys_ai_audit_log"));
assertTrue(ddl.contains("CREATE INDEX IF NOT EXISTS idx_sys_ai_run_task"));
}
}

View File

@@ -0,0 +1,52 @@
package com.eip4.platform.ai.store;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.List;
import java.util.Map;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import com.eip4.platform.ai.model.AiArtifactType;
import com.eip4.platform.ai.model.AiAuditEntry;
import com.eip4.platform.ai.model.AiChangeSet;
import com.eip4.platform.ai.model.AiDraft;
import com.eip4.platform.ai.model.AiGateResult;
import com.eip4.platform.ai.model.AiRunRecord;
import com.eip4.platform.ai.model.AiTask;
import com.fasterxml.jackson.databind.ObjectMapper;
class InMemoryAiAgentStoreTest {
@Test
@DisplayName("内存存储按任务隔离 task/draft/change-set/audit")
void storesTaskScopedArtifacts() {
ObjectMapper mapper = new ObjectMapper();
InMemoryAiAgentStore store = new InMemoryAiAgentStore();
AiTask task = new AiTask("ait-1", "目标", "DRAFTING", 1L, 1L, List.of("plan"));
AiDraft draft = new AiDraft("aid-1", task.id(), AiArtifactType.CODE, "target",
mapper.createObjectNode().put("ok", true), 2L,
List.of(new AiGateResult("required", true, List.of())), Map.of());
AiChangeSet changeSet = new AiChangeSet("aics-1", task.id(), "READY_FOR_REVIEW", 3L,
List.of(draft.id()), Map.of("draftCount", 1));
AiRunRecord run = new AiRunRecord("air-1", task.id(), changeSet.id(), "SMOKE", "PASSED", 4L,
mapper.createObjectNode().put("status", "PASSED"));
AiAuditEntry audit = new AiAuditEntry("aia-1", task.id(), "draft.saved", "agent", 4L, Map.of());
store.saveTask(task);
store.saveDraft(draft);
store.saveChangeSet(changeSet);
store.saveRun(run);
store.saveAudit(audit);
assertTrue(store.findTask(task.id()).isPresent());
assertEquals(1, store.listDrafts(task.id()).size());
assertEquals(1, store.listChangeSets(task.id()).size());
assertEquals(1, store.listRuns(task.id()).size());
assertEquals(1, store.listAudit(task.id()).size());
assertEquals(List.of(), store.listDrafts("other-task"));
assertEquals(List.of(), store.listRuns("other-task"));
}
}

View File

@@ -0,0 +1,121 @@
package com.eip4.platform.ai.store;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.sql.ResultSet;
import java.util.List;
import java.util.Map;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import com.eip4.platform.ai.model.AiRunRecord;
import com.eip4.platform.ai.model.AiTask;
import com.fasterxml.jackson.databind.ObjectMapper;
class JdbcAiAgentStoreTest {
@Test
@DisplayName("JDBC 存储写入 task 使用 sys_ai_task 和 jsonb plan")
void savesTask() {
JdbcTemplate jdbc = mock(JdbcTemplate.class);
JdbcAiAgentStore store = new JdbcAiAgentStore(jdbc, new ObjectMapper());
store.saveTask(new AiTask("ait-1", "目标", "DRAFTING", 1L, 2L, List.of("采集上下文")));
ArgumentCaptor<String> sql = ArgumentCaptor.forClass(String.class);
verify(jdbc).update(sql.capture(), eq("ait-1"), eq("目标"), eq("DRAFTING"),
eq("[\"采集上下文\"]"), eq(1L), eq(2L));
org.junit.jupiter.api.Assertions.assertTrue(sql.getValue().contains("sys_ai_task"));
org.junit.jupiter.api.Assertions.assertTrue(sql.getValue().contains("?::jsonb"));
}
@Test
@DisplayName("JDBC 存储可从 jsonb 行还原 task")
@SuppressWarnings("unchecked")
void mapsTaskRow() throws Exception {
JdbcTemplate jdbc = mock(JdbcTemplate.class);
JdbcAiAgentStore store = new JdbcAiAgentStore(jdbc, new ObjectMapper());
when(jdbc.query(any(String.class), any(RowMapper.class), eq("ait-1"))).thenAnswer(invocation -> {
RowMapper<AiTask> mapper = invocation.getArgument(1);
ResultSet rs = mock(ResultSet.class);
when(rs.getString("task_id")).thenReturn("ait-1");
when(rs.getString("objective")).thenReturn("目标");
when(rs.getString("status")).thenReturn("DRAFTING");
when(rs.getLong("created_at")).thenReturn(1L);
when(rs.getLong("updated_at")).thenReturn(2L);
when(rs.getObject("plan_json")).thenReturn("[\"采集上下文\"]");
return List.of(mapper.mapRow(rs, 0));
});
AiTask task = store.findTask("ait-1").orElseThrow();
assertEquals("目标", task.objective());
assertEquals(List.of("采集上下文"), task.plan());
}
@Test
@DisplayName("JDBC 存储写入 audit 使用 sys_ai_audit_log")
void savesAudit() {
JdbcTemplate jdbc = mock(JdbcTemplate.class);
JdbcAiAgentStore store = new JdbcAiAgentStore(jdbc, new ObjectMapper());
store.saveAudit(new com.eip4.platform.ai.model.AiAuditEntry(
"aia-1", "ait-1", "task.created", "agent", 3L, Map.of("k", "v")));
ArgumentCaptor<String> sql = ArgumentCaptor.forClass(String.class);
verify(jdbc).update(sql.capture(), eq("aia-1"), eq("ait-1"), eq("task.created"),
eq("agent"), eq("{\"k\":\"v\"}"), eq(3L));
org.junit.jupiter.api.Assertions.assertTrue(sql.getValue().contains("sys_ai_audit_log"));
}
@Test
@DisplayName("JDBC 存储写入 run 使用 sys_ai_run 和 jsonb payload")
void savesRun() {
JdbcTemplate jdbc = mock(JdbcTemplate.class);
ObjectMapper mapper = new ObjectMapper();
JdbcAiAgentStore store = new JdbcAiAgentStore(jdbc, mapper);
store.saveRun(new AiRunRecord("air-1", "ait-1", "aics-1", "SMOKE", "PASSED", 5L,
mapper.createObjectNode().put("status", "PASSED")));
ArgumentCaptor<String> sql = ArgumentCaptor.forClass(String.class);
verify(jdbc).update(sql.capture(), eq("air-1"), eq("ait-1"), eq("aics-1"), eq("SMOKE"),
eq("PASSED"), eq("{\"status\":\"PASSED\"}"), eq(5L));
org.junit.jupiter.api.Assertions.assertTrue(sql.getValue().contains("sys_ai_run"));
org.junit.jupiter.api.Assertions.assertTrue(sql.getValue().contains("?::jsonb"));
}
@Test
@DisplayName("JDBC 存储可从 jsonb 行还原 run")
@SuppressWarnings("unchecked")
void mapsRunRow() throws Exception {
JdbcTemplate jdbc = mock(JdbcTemplate.class);
JdbcAiAgentStore store = new JdbcAiAgentStore(jdbc, new ObjectMapper());
when(jdbc.query(any(String.class), any(RowMapper.class), eq("ait-1"))).thenAnswer(invocation -> {
RowMapper<AiRunRecord> mapper = invocation.getArgument(1);
ResultSet rs = mock(ResultSet.class);
when(rs.getString("run_id")).thenReturn("air-1");
when(rs.getString("task_id")).thenReturn("ait-1");
when(rs.getString("change_set_id")).thenReturn("aics-1");
when(rs.getString("run_type")).thenReturn("LOCAL_APPLY");
when(rs.getString("status")).thenReturn("PASSED");
when(rs.getLong("created_at")).thenReturn(5L);
when(rs.getObject("payload_json")).thenReturn("{\"status\":\"PASSED\"}");
return List.of(mapper.mapRow(rs, 0));
});
AiRunRecord run = store.listRuns("ait-1").get(0);
assertEquals("LOCAL_APPLY", run.runType());
assertEquals("PASSED", run.payload().path("status").asText());
}
}

View File

@@ -0,0 +1,120 @@
package com.eip4.platform.ai.web;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import com.eip4.platform.ai.model.AiApplyStepResult;
import com.eip4.platform.ai.model.AiArtifactType;
import com.eip4.platform.ai.model.AiDraft;
import com.eip4.platform.ai.service.AiAgentService;
import com.eip4.platform.ai.service.AiFeatureDraftGenerator;
import com.eip4.platform.ai.service.AiHttpResponse;
import com.eip4.platform.ai.service.AiLocalReleaseExecutor;
import com.eip4.platform.ai.service.AiSmokeRunner;
import com.eip4.platform.ai.service.DeterministicAiAgentRepairExecutor;
import com.eip4.platform.ai.store.InMemoryAiAgentStore;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
class AiAgentApiPipelineTest {
private static final ObjectMapper MAPPER = new ObjectMapper();
private AiAgentService service;
private MockMvc mvc;
@BeforeEach
void setUp() {
AtomicInteger smokeCalls = new AtomicInteger();
AiSmokeRunner flakySmokeRunner = new AiSmokeRunner((method, uri, requestBody, timeout) -> {
if (smokeCalls.incrementAndGet() <= 4) {
return new AiHttpResponse(503, "temporary unavailable");
}
return new AiHttpResponse(200, "{\"status\":0}");
});
service = new AiAgentService(new InMemoryAiAgentStore(), new AiFeatureDraftGenerator(MAPPER),
flakySmokeRunner, new NoopLocalReleaseExecutor(),
new DeterministicAiAgentRepairExecutor(MAPPER), MAPPER);
mvc = MockMvcBuilders.standaloneSetup(new AiAgentController(service)).build();
}
@Test
void autoDevelopEndpointRunsFullPipelineWithAutomaticRepair() throws Exception {
MvcResult result = mvc.perform(post("/api/ai/features/auto-develop")
.contentType("application/json")
.content("""
{
"baseUrl": "http://localhost:8084",
"generateDeploymentPackage": true,
"feature": {
"objective": "新增客户等级维护功能",
"featureName": "客户等级维护",
"tableName": "EIP4AI_CUSTOMER_LEVEL",
"entityName": "客户等级",
"templateId": "eip4ai-customer-level",
"menuName": "客户等级维护",
"fields": [
{"column": "NAME", "label": "名称", "type": "string", "length": 100, "required": true},
{"column": "CODE", "label": "编码", "type": "string", "length": 64, "required": true},
{"column": "ENABLED", "label": "启用", "type": "boolean", "required": false}
]
}
}
"""))
.andExpect(status().isOk())
.andExpect(jsonPath("$.status").value("READY_FOR_HUMAN_REVIEW"))
.andExpect(jsonPath("$.originalChangeSetId").isNotEmpty())
.andExpect(jsonPath("$.changeSetId").isNotEmpty())
.andExpect(jsonPath("$.development.drafts.length()").value(5))
.andExpect(jsonPath("$.applyRun.status").value("PASSED"))
.andExpect(jsonPath("$.repairExecutions.length()").value(1))
.andExpect(jsonPath("$.repairExecutions[0].status").value("REPAIRED"))
.andExpect(jsonPath("$.deploymentPackage.status").value("READY_FOR_HUMAN_REVIEW"))
.andExpect(jsonPath("$.deploymentPackage.requiresHumanApproval").value(true))
.andReturn();
JsonNode response = MAPPER.readTree(result.getResponse().getContentAsString());
String taskId = response.path("taskId").asText();
assertTrue(service.listRuns(taskId).stream().anyMatch(run -> "AUTO_DEVELOP".equals(run.runType())));
assertTrue(service.listRuns(taskId).stream().anyMatch(run -> "REPAIR_EXECUTION".equals(run.runType())));
assertTrue(service.listAudit(taskId).stream().anyMatch(audit -> "auto-development.completed".equals(audit.action())));
}
private static class NoopLocalReleaseExecutor extends AiLocalReleaseExecutor {
NoopLocalReleaseExecutor() {
super(org.mockito.Mockito.mock(org.springframework.jdbc.core.JdbcTemplate.class),
(method, uri, requestBody, timeout) -> new AiHttpResponse(200, "{\"status\":0}"), MAPPER);
}
@Override
public java.util.List<AiApplyStepResult> apply(String baseUrl, java.util.List<AiDraft> drafts) {
return drafts.stream()
.filter(draft -> draft.artifactType() != AiArtifactType.TEST)
.map(draft -> new AiApplyStepResult("apply-" + draft.id(), draft.artifactType(),
draft.targetId(), "APPLIED", "ok", details(draft)))
.toList();
}
private static Map<String, Object> details(AiDraft draft) {
return switch (draft.artifactType()) {
case ENTITY -> Map.of("entityId", "e-test-entity-id", "tableName", draft.targetId());
case SERVICEFLOW -> Map.of("flowCount", 5, "entityId", "e-test-entity-id");
case PAGE_SCHEMA -> Map.of("templateId", draft.targetId(), "etag", "test-etag");
case MENU -> Map.of("menuId", "m-test-menu-id");
case CODE, TEST -> Map.of();
};
}
}
}

View File

@@ -0,0 +1,222 @@
package com.eip4.platform.ai.web;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
import java.util.List;
import java.util.Map;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import com.eip4.platform.ai.model.AiApplyRun;
import com.eip4.platform.ai.model.AiApplyStepResult;
import com.eip4.platform.ai.model.AiArtifactType;
import com.eip4.platform.ai.model.AiAutoDevelopmentRequest;
import com.eip4.platform.ai.model.AiAutoDevelopmentRun;
import com.eip4.platform.ai.model.AiChangeSet;
import com.eip4.platform.ai.model.AiDeploymentPackage;
import com.eip4.platform.ai.model.AiDraft;
import com.eip4.platform.ai.model.AiFeatureDevelopment;
import com.eip4.platform.ai.model.AiFeatureField;
import com.eip4.platform.ai.model.AiFeatureRequest;
import com.eip4.platform.ai.model.AiGateResult;
import com.eip4.platform.ai.model.AiReleasePlan;
import com.eip4.platform.ai.model.AiReleaseStep;
import com.eip4.platform.ai.model.AiRepairAction;
import com.eip4.platform.ai.model.AiRepairExecution;
import com.eip4.platform.ai.model.AiRepairExecutionRequest;
import com.eip4.platform.ai.model.AiRepairPlan;
import com.eip4.platform.ai.model.AiRunRecord;
import com.eip4.platform.ai.model.AiSmokeResult;
import com.eip4.platform.ai.model.AiSmokeRun;
import com.eip4.platform.ai.model.AiTask;
import com.eip4.platform.ai.service.AiAgentService;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
@ExtendWith(MockitoExtension.class)
class AiAgentControllerTest {
@Mock
AiAgentService service;
MockMvc mvc;
ObjectMapper objectMapper;
@BeforeEach
void setUp() {
objectMapper = new ObjectMapper();
mvc = MockMvcBuilders.standaloneSetup(new AiAgentController(service)).build();
}
@Test
void 一键自动开发转调service并返回执行证据() throws Exception {
AiAutoDevelopmentRun run = autoDevelopmentRun();
when(service.autoDevelopFeature(any(AiAutoDevelopmentRequest.class))).thenReturn(run);
AiAutoDevelopmentRequest request = new AiAutoDevelopmentRequest(
new AiFeatureRequest("开发客户管理", "客户管理", "SYS_CUSTOMER",
"Customer", "list-form", "客户管理",
List.of(new AiFeatureField("NAME", "客户名称", "text", 64, true))),
"http://127.0.0.1:18080",
true,
2);
mvc.perform(post("/api/ai/features/auto-develop")
.contentType("application/json")
.content(objectMapper.writeValueAsString(request)))
.andExpect(status().isOk())
.andExpect(jsonPath("$.taskId").value("ait-1"))
.andExpect(jsonPath("$.changeSetId").value("aics-1"))
.andExpect(jsonPath("$.originalChangeSetId").value("aics-0"))
.andExpect(jsonPath("$.status").value("READY_FOR_DEPLOYMENT_REVIEW"))
.andExpect(jsonPath("$.applyRun.smokeRun.results[0].passed").value(true))
.andExpect(jsonPath("$.repairExecutions").isArray())
.andExpect(jsonPath("$.deploymentPackage.requiresHumanApproval").value(true));
ArgumentCaptor<AiAutoDevelopmentRequest> captor = ArgumentCaptor.forClass(AiAutoDevelopmentRequest.class);
verify(service).autoDevelopFeature(captor.capture());
assertEquals("客户管理", captor.getValue().feature().featureName());
assertEquals("http://127.0.0.1:18080", captor.getValue().baseUrl());
assertTrue(captor.getValue().shouldGenerateDeploymentPackage());
assertEquals(2, captor.getValue().repairAttemptLimit());
}
@Test
void 修复计划接口返回自动化动作() throws Exception {
AiRepairPlan plan = repairPlan();
when(service.createRepairPlan("ait-1", "aics-1")).thenReturn(plan);
mvc.perform(post("/api/ai/tasks/ait-1/change-sets/aics-1/repair-plan"))
.andExpect(status().isOk())
.andExpect(jsonPath("$.taskId").value("ait-1"))
.andExpect(jsonPath("$.actions[0].artifactType").value("TEST"))
.andExpect(jsonPath("$.actions[0].automated").value(true));
verify(service).createRepairPlan("ait-1", "aics-1");
}
@Test
void 执行修复接口透传baseUrl并返回重跑结果() throws Exception {
AiRepairExecution execution = repairExecution();
when(service.executeRepairPlan(eq("ait-1"), eq("aics-1"), eq("http://localhost:18080")))
.thenReturn(execution);
AiRepairExecutionRequest request = new AiRepairExecutionRequest("http://localhost:18080");
mvc.perform(post("/api/ai/tasks/ait-1/change-sets/aics-1/repair-execution")
.contentType("application/json")
.content(objectMapper.writeValueAsString(request)))
.andExpect(status().isOk())
.andExpect(jsonPath("$.status").value("PASSED"))
.andExpect(jsonPath("$.generatedDrafts[0].artifactType").value("PAGE_SCHEMA"))
.andExpect(jsonPath("$.retryApplyRun.smokeRun.status").value("PASSED"));
verify(service).executeRepairPlan("ait-1", "aics-1", "http://localhost:18080");
}
@Test
void schema校验接口转发JsonNode() throws Exception {
when(service.validateSchema(any(JsonNode.class))).thenReturn(Map.of(
"valid", true,
"warnings", List.of()));
mvc.perform(post("/api/ai/tools/validate-schema")
.contentType("application/json")
.content("{\"type\":\"page\",\"title\":\"客户\",\"body\":[]}"))
.andExpect(status().isOk())
.andExpect(jsonPath("$.valid").value(true));
ArgumentCaptor<JsonNode> captor = ArgumentCaptor.forClass(JsonNode.class);
verify(service).validateSchema(captor.capture());
assertEquals("page", captor.getValue().path("type").asText());
}
private AiAutoDevelopmentRun autoDevelopmentRun() {
AiFeatureDevelopment development = new AiFeatureDevelopment(task(), List.of(draft()), changeSet());
AiReleasePlan releasePlan = new AiReleasePlan("ait-1", "aics-1", "READY",
true,
Map.of("policy", "local-only"),
List.of(new AiReleaseStep("step-1", AiArtifactType.PAGE_SCHEMA, "页面",
"LOCAL_APPLY", "customer-page", "UPSERT", Map.of())),
List.of("按变更包反向回滚"));
AiApplyRun applyRun = applyRun();
AiDeploymentPackage deploymentPackage = deploymentPackage();
return new AiAutoDevelopmentRun("ait-1", "aics-1", "aics-0", "READY_FOR_DEPLOYMENT_REVIEW",
100L, 200L, development, releasePlan, applyRun, deploymentPackage,
List.of(),
List.of("本地门禁通过,等待人工部署"));
}
private AiRepairExecution repairExecution() {
return new AiRepairExecution("ait-1", "aics-1", "PASSED",
100L, 200L, repairPlan(), List.of(draft()), changeSet(), applyRun(),
deploymentPackage(), List.of("已生成修复草稿并通过本地 smoke"));
}
private AiRepairPlan repairPlan() {
return new AiRepairPlan("ait-1", "aics-1", "run-1", "READY",
100L,
List.of(new AiRepairAction("repair-1", "SMOKE", "PATCH_DRAFT",
"TEST", "customer-smoke", true, "同步测试契约",
Map.of("expectedStatus", 200))),
List.of("发现测试契约不匹配"));
}
private AiTask task() {
return new AiTask("ait-1", "开发客户管理", "READY_FOR_REVIEW",
1L, 2L, List.of("生成草稿", "本地验证"));
}
private AiDraft draft() {
return new AiDraft("aid-1", "ait-1", AiArtifactType.PAGE_SCHEMA, "customer-page",
objectMapper.createObjectNode()
.put("type", "page")
.put("title", "客户管理")
.set("body", objectMapper.createArrayNode()),
3L,
List.of(new AiGateResult("schema", true, List.of())),
Map.of("source", "test"));
}
private AiChangeSet changeSet() {
return new AiChangeSet("aics-1", "ait-1", "READY_FOR_REVIEW",
4L, List.of("aid-1"), Map.of("draftCount", 1));
}
private AiApplyRun applyRun() {
AiSmokeRun smokeRun = new AiSmokeRun("ait-1", "aics-1", "http://localhost:18080",
"PASSED", 10L, 20L,
List.of(new AiSmokeResult("打开页面", "GET", "/customer",
200, 200, true, 12L, null, "ok")));
return new AiApplyRun("ait-1", "aics-1", "http://localhost:18080",
"PASSED", 5L, 25L,
List.of(new AiApplyStepResult("step-1", AiArtifactType.PAGE_SCHEMA,
"customer-page", "APPLIED", "ok", Map.of())),
smokeRun);
}
private AiDeploymentPackage deploymentPackage() {
return new AiDeploymentPackage("ait-1", "aics-1", "READY_FOR_HUMAN_APPROVAL",
true, 30L, Map.of("changeSetId", "aics-1"),
List.of("insert into sys_page_schema ..."),
List.of("delete from sys_page_schema where id = 'customer-page'"),
List.of(),
List.<AiRunRecord>of());
}
}

View File

@@ -22,6 +22,10 @@ spring:
hikari: hikari:
maximum-pool-size: 10 maximum-pool-size: 10
read-only: false read-only: false
sql:
init:
mode: always
schema-locations: classpath:bootstrap/bootstrap-ai-agent.sql
eip4: eip4:
auth: auth:
@@ -29,6 +33,14 @@ eip4:
secret: ${EIP4_AUTH_JWT_SECRET:dev-only-eip4-jwt-secret-change-me-in-production-0123456789} secret: ${EIP4_AUTH_JWT_SECRET:dev-only-eip4-jwt-secret-change-me-in-production-0123456789}
expire-seconds: 28800 # 8h expire-seconds: 28800 # 8h
issuer: eip4-platform issuer: eip4-platform
ai:
store: jdbc
llm:
repair:
enabled: ${EIP4_AI_LLM_REPAIR_ENABLED:false}
endpoint: ${EIP4_AI_LLM_REPAIR_ENDPOINT:}
api-key: ${EIP4_AI_LLM_REPAIR_API_KEY:}
model: ${EIP4_AI_LLM_REPAIR_MODEL:}
file: file:
root: ${EIP4_FILE_ROOT:./data/files} root: ${EIP4_FILE_ROOT:./data/files}
script: script:

View File

@@ -13,6 +13,10 @@ spring:
hikari: hikari:
maximum-pool-size: 5 maximum-pool-size: 5
read-only: false read-only: false
sql:
init:
mode: always
schema-locations: classpath:bootstrap/bootstrap-ai-agent.sql
server: server:
port: 8084 port: 8084
@@ -25,6 +29,14 @@ eip4:
secret: ${EIP4_AUTH_JWT_SECRET:dev-only-eip4-jwt-secret-change-me-in-production-0123456789} secret: ${EIP4_AUTH_JWT_SECRET:dev-only-eip4-jwt-secret-change-me-in-production-0123456789}
expire-seconds: 28800 # 8h expire-seconds: 28800 # 8h
issuer: eip4-platform issuer: eip4-platform
ai:
store: jdbc
llm:
repair:
enabled: ${EIP4_AI_LLM_REPAIR_ENABLED:false}
endpoint: ${EIP4_AI_LLM_REPAIR_ENDPOINT:}
api-key: ${EIP4_AI_LLM_REPAIR_API_KEY:}
model: ${EIP4_AI_LLM_REPAIR_MODEL:}
logging: logging:
level: level:

View File

@@ -0,0 +1,68 @@
-- ============================================================================
-- eip4-platform P5 AI Agent 运行态自举 schema —— bootstrap-ai-agent.sql
-- ----------------------------------------------------------------------------
-- 用途:platform-app 启动器本地/dev profile 直接加载的 AI Agent 表自举脚本。
--
-- 纪律:可重复执行(CREATE TABLE IF NOT EXISTS / CREATE INDEX IF NOT EXISTS);
-- 只保存 AI 运行态和草稿,不直接写 SYS_PAGE_SCHEMA / SYS_ENTITY / 服务流等生产元数据。
-- platform-ai 模块内保留同名副本,生产脚本副本见 docs/sql/SYS_AI_AGENT.sql。
-- ============================================================================
CREATE TABLE IF NOT EXISTS sys_ai_task (
task_id character varying(64) NOT NULL,
objective text NOT NULL,
status character varying(32) NOT NULL,
plan_json jsonb NOT NULL,
created_at bigint NOT NULL,
updated_at bigint NOT NULL,
CONSTRAINT pk_sys_ai_task PRIMARY KEY (task_id)
);
CREATE TABLE IF NOT EXISTS sys_ai_draft (
draft_id character varying(64) NOT NULL,
task_id character varying(64) NOT NULL,
artifact_type character varying(32) NOT NULL,
target_id character varying(128) NOT NULL,
payload_json jsonb NOT NULL,
gates_json jsonb NOT NULL,
metadata_json jsonb NOT NULL,
created_at bigint NOT NULL,
CONSTRAINT pk_sys_ai_draft PRIMARY KEY (draft_id)
);
CREATE TABLE IF NOT EXISTS sys_ai_change_set (
change_set_id character varying(64) NOT NULL,
task_id character varying(64) NOT NULL,
status character varying(32) NOT NULL,
draft_ids_json jsonb NOT NULL,
summary_json jsonb NOT NULL,
created_at bigint NOT NULL,
CONSTRAINT pk_sys_ai_change_set PRIMARY KEY (change_set_id)
);
CREATE TABLE IF NOT EXISTS sys_ai_run (
run_id character varying(64) NOT NULL,
task_id character varying(64) NOT NULL,
change_set_id character varying(64) NOT NULL,
run_type character varying(32) NOT NULL,
status character varying(32) NOT NULL,
payload_json jsonb NOT NULL,
created_at bigint NOT NULL,
CONSTRAINT pk_sys_ai_run PRIMARY KEY (run_id)
);
CREATE TABLE IF NOT EXISTS sys_ai_audit_log (
audit_id character varying(64) NOT NULL,
task_id character varying(64) NOT NULL,
action character varying(96) NOT NULL,
actor character varying(64) NOT NULL,
details_json jsonb NOT NULL,
created_at bigint NOT NULL,
CONSTRAINT pk_sys_ai_audit_log PRIMARY KEY (audit_id)
);
CREATE INDEX IF NOT EXISTS idx_sys_ai_draft_task ON sys_ai_draft (task_id, created_at);
CREATE INDEX IF NOT EXISTS idx_sys_ai_change_set_task ON sys_ai_change_set (task_id, created_at);
CREATE INDEX IF NOT EXISTS idx_sys_ai_run_task ON sys_ai_run (task_id, created_at);
CREATE INDEX IF NOT EXISTS idx_sys_ai_run_change_set ON sys_ai_run (change_set_id, created_at);
CREATE INDEX IF NOT EXISTS idx_sys_ai_audit_log_task ON sys_ai_audit_log (task_id, created_at);

View File

@@ -92,7 +92,7 @@ public class MetaController {
// 属性模板:取 SYS_USERGROUP.NAME 属性行做默认值载体 // 属性模板:取 SYS_USERGROUP.NAME 属性行做默认值载体
Map<String, Object> attrTpl = loadAttrTemplate(idOf(tplEnt)); Map<String, Object> attrTpl = loadAttrTemplate(idOf(tplEnt));
List<Map<String, Object>> created = new ArrayList<>(); List<GeneralPOJO> created = new ArrayList<>();
// 标准列 // 标准列
created.add(saveAttr(attrTpl, entityId, table + "_ID", "主键", "CHAR", 36, true, true, ctx)); created.add(saveAttr(attrTpl, entityId, table + "_ID", "主键", "CHAR", 36, true, true, ctx));
created.add(saveAttr(attrTpl, entityId, "VERSION", "版本", "INTEGER", null, true, false, ctx)); created.add(saveAttr(attrTpl, entityId, "VERSION", "版本", "INTEGER", null, true, false, ctx));
@@ -125,9 +125,9 @@ public class MetaController {
} }
} }
// 动态建表 // 动态建表前先清刚保存实体/属性带来的 POInfo 缓存,保证后续读写立即拿到新字段。
Entity newEnt = (Entity) dataDicService.getSYSEntity(entityId); cacheInvalidator.evictByEntityId(entityId, table);
String ddl = newEnt.createTableSql(); String ddl = createTableDdl(table, created);
dataDicService.executeCreateSql(ddl); dataDicService.executeCreateSql(ddl);
// P1-5:建表后按元数据补索引(外键 uuid 列 + UPDATETIME),引擎只建表不建索引 // P1-5:建表后按元数据补索引(外键 uuid 列 + UPDATETIME),引擎只建表不建索引
@@ -224,7 +224,7 @@ public class MetaController {
return resp; return resp;
} }
private Map<String, Object> saveAttr(Map<String, Object> tpl, String entityId, String col, private GeneralPOJO saveAttr(Map<String, Object> tpl, String entityId, String col,
String display, String ref, Integer len, String display, String ref, Integer len,
boolean mandatory, boolean isKey, Properties ctx) { boolean mandatory, boolean isKey, Properties ctx) {
Map<String, Object> m = new HashMap<>(tpl); Map<String, Object> m = new HashMap<>(tpl);
@@ -243,8 +243,100 @@ public class MetaController {
} else { } else {
m.remove("FIELDLENGTH"); m.remove("FIELDLENGTH");
} }
pojoCRUDService.save(m, "SYS_ENTITYATTRIBUTE", ctx); return pojoCRUDService.save(m, "SYS_ENTITYATTRIBUTE", ctx);
return Map.of("column", col, "type", ref); }
static String createTableDdl(String table, List<GeneralPOJO> attrs) {
if (attrs == null || attrs.isEmpty()) {
throw new IllegalStateException("实体属性为空,无法建表: " + table);
}
StringBuilder sql = new StringBuilder();
StringBuilder unique = new StringBuilder();
StringBuilder combUnique = new StringBuilder();
sql.append("CREATE TABLE ").append(table).append("\n");
sql.append("(\n");
for (GeneralPOJO attr : attrs) {
appendColumnDdl(table, attr, sql, unique, combUnique);
}
sql.append(unique);
if (!combUnique.isEmpty()) {
sql.append(combUnique).append("), \n");
}
sql.append("primary key (").append(table).append("_ID)\n");
sql.append("); \n");
return sql.toString();
}
private static void appendColumnDdl(String table, GeneralPOJO attr, StringBuilder sql,
StringBuilder unique, StringBuilder combUnique) {
if (attr.get_ValueAsBoolean("ISREADONLY")) {
return;
}
String ref = value(attr, "REFERENCEID");
if ("LIST".equals(ref) || "BLOB".equals(ref) || "STATUS".equals(ref)) {
return;
}
String col = value(attr, "COLUMNNAME");
if (col == null || !col.matches("[A-Z][A-Z0-9_]{1,60}")) {
throw new IllegalStateException("实体字段名不合法: " + col);
}
if ("CREATEBY".equals(col) || "UPDATEBY".equals(col) || "ORGID".equals(col) || "DEPARTID".equals(col)) {
sql.append(col).append(" character(36) ");
} else if ("NVARCHAR".equals(ref) || "CODE".equals(ref)) {
int length = positiveInt(attr.get_Value("FIELDLENGTH"), 100);
sql.append(col).append(" character varying(").append(length).append(") ");
} else if ("INTEGER".equals(ref) || "BOOLEAN".equals(ref) || "ENUMERATE".equals(ref)) {
sql.append(col).append(" integer ");
} else if ("DECIMAL".equals(ref) || "MONEY".equals(ref)) {
sql.append(col).append(" numeric(18,6) ");
} else if ("DATE".equals(ref) || "TIME".equals(ref)) {
sql.append(col).append(" bigint ");
} else if ("CHAR".equals(ref)) {
sql.append(col).append(" character(36) ");
} else {
sql.append(col).append(" character(36) REFERENCES ").append(table);
}
if (attr.get_ValueAsBoolean("ISMANDATORY")) {
sql.append(" NOT NULL ");
}
String defValue = value(attr, "DEFAULTVALUE");
if (defValue != null && !defValue.isBlank()
&& ("INTEGER".equals(ref) || "BOOLEAN".equals(ref) || "DECIMAL".equals(ref) || "MONEY".equals(ref))) {
sql.append(" DEFAULT ").append(defValue);
}
sql.append(", \n");
if (attr.get_ValueAsBoolean("ISIDENTIFIER")) {
unique.append(" unique (").append(col).append("), \n");
} else if (attr.get_ValueAsBoolean("ISCOMBIDENTIFIER")) {
if (combUnique.isEmpty()) {
combUnique.append(" unique (");
} else {
combUnique.append(",");
}
combUnique.append(col);
}
}
private static int positiveInt(Object value, int defaultValue) {
if (value instanceof Number n && n.intValue() > 0) {
return n.intValue();
}
if (value != null) {
try {
int parsed = Integer.parseInt(value.toString());
if (parsed > 0) {
return parsed;
}
} catch (NumberFormatException ignore) {
return defaultValue;
}
}
return defaultValue;
}
private static String value(GeneralPOJO po, String column) {
Object value = po.get_Value(column);
return value == null ? null : value.toString();
} }
private Map<String, Object> loadAttrTemplate(String tplEntityId) { private Map<String, Object> loadAttrTemplate(String tplEntityId) {

View File

@@ -0,0 +1,40 @@
package com.eip4.platform.metadata.web;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.util.List;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import com.dsasp.server.common.dataDic.bean.GeneralPOJO;
class MetaControllerDdlTest {
@Test
@DisplayName("运行态实体 DDL 按旧引擎类型规则生成主键、字符串和布尔列")
void createTableDdlUsesSavedAttributes() {
String ddl = MetaController.createTableDdl("EIP4AI_RT_DEMO", List.of(
attr("EIP4AI_RT_DEMO_ID", "CHAR", null, true),
attr("NAME", "NVARCHAR", 100, true),
attr("ENABLED", "BOOLEAN", null, false)
));
assertTrue(ddl.contains("CREATE TABLE EIP4AI_RT_DEMO"));
assertTrue(ddl.contains("EIP4AI_RT_DEMO_ID character(36) NOT NULL"));
assertTrue(ddl.contains("NAME character varying(100) NOT NULL"));
assertTrue(ddl.contains("ENABLED integer"));
assertTrue(ddl.contains("primary key (EIP4AI_RT_DEMO_ID)"));
}
private static GeneralPOJO attr(String column, String referenceId, Integer length, boolean mandatory) {
GeneralPOJO po = mock(GeneralPOJO.class);
when(po.get_Value("COLUMNNAME")).thenReturn(column);
when(po.get_Value("REFERENCEID")).thenReturn(referenceId);
when(po.get_Value("FIELDLENGTH")).thenReturn(length);
when(po.get_ValueAsBoolean("ISMANDATORY")).thenReturn(mandatory);
return po;
}
}