@josephyan/qingflow-cli 0.2.0-beta.55

package/src/qingflow_mcp/solution/build_assembly_store.py

@@ -0,0 +1,181 @@
+from __future__ import annotations
+
+import json
+import os
+from copy import deepcopy
+from dataclasses import dataclass
+from pathlib import Path
+import tempfile
+from typing import Any
+
+from ..config import get_mcp_home
+from .run_store import resolve_storage_path, utc_now
+
+
+def get_build_assemblies_path() -> Path:
+    custom_home = os.getenv("QINGFLOW_MCP_BUILD_HOME")
+    if custom_home:
+        return Path(custom_home).expanduser()
+    return get_mcp_home() / "build-assemblies"
+
+
+def default_manifest() -> dict[str, Any]:
+    return {
+        "solution_name": "",
+        "summary": None,
+        "business_context": {},
+        "package": {"enabled": True, "ordinal": 1},
+        "entities": [],
+        "roles": [],
+        "requirements": [],
+        "success_metrics": [],
+        "portal": {"enabled": False, "sections": []},
+        "navigation": {"enabled": False, "items": []},
+        "publish_policy": {"apps": True, "portal": True, "navigation": True},
+        "preferences": {
+            "multi_app": None,
+            "create_package": True,
+            "create_portal": False,
+            "create_navigation": False,
+            "naming_style": "title",
+        },
+        "assumptions": [],
+        "constraints": [],
+        "metadata": {},
+    }
+
+
+def default_artifacts() -> dict[str, Any]:
+    return {
+        "package": {},
+        "roles": {},
+        "apps": {},
+        "views": {},
+        "charts": {},
+        "records": {},
+        "portal": {},
+        "navigation": {},
+        "field_maps": {},
+    }
+
+
+def default_builder_state() -> dict[str, Any]:
+    return {
+        "generated_specs": {},
+        "failure_signatures": {},
+        "last_failure_signature": None,
+        "last_failure_stage": None,
+        "last_failure_count": 0,
+    }
+
+
+@dataclass(slots=True)
+class BuildAssemblyStore:
+    path: Path
+    data: dict[str, Any]
+
+    @classmethod
+    def open(cls, *, build_id: str, create: bool = True) -> "BuildAssemblyStore":
+        base_dir = get_build_assemblies_path()
+        try:
+            base_dir.mkdir(parents=True, exist_ok=True)
+        except PermissionError:
+            base_dir = Path(tempfile.gettempdir()) / "qingflow-mcp-build-assemblies"
+            base_dir.mkdir(parents=True, exist_ok=True)
+        path = resolve_storage_path(base_dir, key=build_id, id_field="build_id")
+        if path.exists():
+            data = json.loads(path.read_text(encoding="utf-8"))
+            stored_build_id = data.get("build_id")
+            if stored_build_id != build_id:
+                raise ValueError(f"existing build assembly at '{path}' belongs to '{stored_build_id}', not '{build_id}'")
+        elif not create:
+            raise FileNotFoundError(build_id)
+        else:
+            data = {
+                "build_id": build_id,
+                "status": "draft",
+                "manifest": default_manifest(),
+                "stage_specs": {
+                    "app_flow": {},
+                    "views": {},
+                    "analytics_portal": {},
+                    "navigation": {},
+                },
+                "artifacts": default_artifacts(),
+                "builder_state": default_builder_state(),
+                "stage_history": [],
+                "created_at": utc_now(),
+                "updated_at": utc_now(),
+            }
+            try:
+                path.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+            except PermissionError:
+                base_dir = Path(tempfile.gettempdir()) / "qingflow-mcp-build-assemblies"
+                base_dir.mkdir(parents=True, exist_ok=True)
+                path = resolve_storage_path(base_dir, key=build_id, id_field="build_id")
+                path.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+        return cls(path=path, data=data)
+
+    def get_manifest(self) -> dict[str, Any]:
+        return deepcopy(self.data.get("manifest", default_manifest()))
+
+    def set_manifest(self, manifest: dict[str, Any]) -> None:
+        self.data["manifest"] = deepcopy(manifest)
+        self._flush()
+
+    def get_artifacts(self) -> dict[str, Any]:
+        return deepcopy(self.data.get("artifacts", default_artifacts()))
+
+    def set_artifacts(self, artifacts: dict[str, Any]) -> None:
+        self.data["artifacts"] = deepcopy(artifacts)
+        self._flush()
+
+    def set_stage_spec(self, stage_name: str, spec: dict[str, Any]) -> None:
+        self.data.setdefault("stage_specs", {})
+        self.data["stage_specs"][stage_name] = deepcopy(spec)
+        self._flush()
+
+    def add_stage_history(self, entry: dict[str, Any]) -> None:
+        self.data.setdefault("stage_history", []).append(deepcopy(entry))
+        self._flush()
+
+    def mark_status(self, status: str) -> None:
+        self.data["status"] = status
+        self._flush()
+
+    def get_builder_state(self) -> dict[str, Any]:
+        return deepcopy(self.data.get("builder_state", default_builder_state()))
+
+    def set_builder_state(self, builder_state: dict[str, Any]) -> None:
+        self.data["builder_state"] = deepcopy(builder_state)
+        self._flush()
+
+    def get_builder_value(self, key: str, default: Any = None) -> Any:
+        return deepcopy(self.data.get("builder_state", {}).get(key, default))
+
+    def set_builder_value(self, key: str, value: Any) -> None:
+        self.data.setdefault("builder_state", default_builder_state())
+        self.data["builder_state"][key] = deepcopy(value)
+        self._flush()
+
+    def summary(self) -> dict[str, Any]:
+        return {
+            "build_id": self.data["build_id"],
+            "status": self.data["status"],
+            "manifest": deepcopy(self.data.get("manifest", {})),
+            "artifacts": deepcopy(self.data.get("artifacts", {})),
+            "builder_state": deepcopy(self.data.get("builder_state", {})),
+            "stage_specs": deepcopy(self.data.get("stage_specs", {})),
+            "stage_history": deepcopy(self.data.get("stage_history", [])),
+            "build_path": str(self.path),
+        }
+
+    def _flush(self) -> None:
+        self.data["updated_at"] = utc_now()
+        try:
+            self.path.write_text(json.dumps(self.data, ensure_ascii=False, indent=2), encoding="utf-8")
+        except PermissionError:
+            fallback_dir = Path(tempfile.gettempdir()) / "qingflow-mcp-build-assemblies"
+            fallback_dir.mkdir(parents=True, exist_ok=True)
+            self.path = resolve_storage_path(fallback_dir, key=str(self.data.get("build_id") or "build"), id_field="build_id")
+            self.path.write_text(json.dumps(self.data, ensure_ascii=False, indent=2), encoding="utf-8")

package/src/qingflow_mcp/solution/compiler/__init__.py

@@ -0,0 +1,282 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from ..spec_models import EntitySpec, PortalSourceType, RoleSpec, SolutionSpec
+from .chart_compiler import compile_charts
+from .form_compiler import compile_entity_form
+from .navigation_compiler import compile_navigation
+from .package_compiler import compile_package
+from .portal_compiler import compile_portal
+from .view_compiler import compile_views
+from .workflow_compiler import compile_workflow
+
+
+@dataclass(slots=True)
+class ExecutionStep:
+    step_name: str
+    resource_type: str
+    resource_ref: str
+    description: str
+    depends_on: list[str] = field(default_factory=list)
+
+
+@dataclass(slots=True)
+class ExecutionPlan:
+    steps: list[ExecutionStep]
+
+    def as_dict(self) -> dict[str, Any]:
+        return {
+            "steps": [
+                {
+                    "step_name": step.step_name,
+                    "resource_type": step.resource_type,
+                    "resource_ref": step.resource_ref,
+                    "description": step.description,
+                    "depends_on": step.depends_on,
+                }
+                for step in self.steps
+            ]
+        }
+
+
+@dataclass(slots=True)
+class CompiledRole:
+    role_id: str
+    name: str
+    payload: dict[str, Any]
+
+
+@dataclass(slots=True)
+class CompiledEntity:
+    entity_id: str
+    display_name: str
+    app_create_payload: dict[str, Any]
+    form_base_payload: dict[str, Any]
+    form_relation_payload: dict[str, Any] | None
+    field_specs: dict[str, dict[str, Any]]
+    field_labels: dict[str, str]
+    workflow_plan: dict[str, Any] | None
+    view_plans: list[dict[str, Any]]
+    chart_plans: list[dict[str, Any]]
+    sample_records: list[dict[str, Any]]
+
+
+@dataclass(slots=True)
+class CompiledSolution:
+    normalized_spec: SolutionSpec
+    package_payload: dict[str, Any] | None
+    roles: list[CompiledRole]
+    entities: list[CompiledEntity]
+    portal_plan: dict[str, Any] | None
+    navigation_plan: list[dict[str, Any]]
+    execution_plan: ExecutionPlan
+
+    def as_dict(self) -> dict[str, Any]:
+        return {
+            "normalized_solution_spec": self.normalized_spec.model_dump(mode="json"),
+            "execution_plan": self.execution_plan.as_dict(),
+        }
+
+
+def compile_solution(spec: SolutionSpec) -> CompiledSolution:
+    package_payload = compile_package(spec)
+    roles = [compile_role(role) for role in spec.roles]
+    entities = [compile_entity(entity, include_package=package_payload is not None) for entity in spec.entities]
+    _apply_portal_chart_semantics(spec, entities)
+    portal_plan = compile_portal(spec)
+    navigation_plan = compile_navigation(spec)
+    execution_plan = build_execution_plan(spec, package_payload is not None)
+    return CompiledSolution(
+        normalized_spec=spec,
+        package_payload=package_payload,
+        roles=roles,
+        entities=entities,
+        portal_plan=portal_plan,
+        navigation_plan=navigation_plan,
+        execution_plan=execution_plan,
+    )
+
+
+def compile_entity(entity: EntitySpec, *, include_package: bool) -> CompiledEntity:
+    app_create_payload, form_base_payload, form_relation_payload, field_specs, field_labels = compile_entity_form(entity, include_package=include_package)
+    workflow_plan = compile_workflow(entity)
+    view_plans = compile_views(entity)
+    chart_plans = compile_charts(entity)
+    return CompiledEntity(
+        entity_id=entity.entity_id,
+        display_name=entity.display_name,
+        app_create_payload=app_create_payload,
+        form_base_payload=form_base_payload,
+        form_relation_payload=form_relation_payload,
+        field_specs=field_specs,
+        field_labels=field_labels,
+        workflow_plan=workflow_plan,
+        view_plans=view_plans,
+        chart_plans=chart_plans,
+        sample_records=[record.model_dump(mode="json") for record in entity.sample_records],
+    )
+
+
+def compile_role(role: RoleSpec) -> CompiledRole:
+    payload = {
+        "roleName": role.name,
+        "roleIcon": role.icon or role.config.get("roleIcon") or "ex-user-outlined",
+        "users": list(role.users),
+    }
+    return CompiledRole(role_id=role.role_id, name=role.name, payload=payload)
+
+
+def build_execution_plan(
+    spec: SolutionSpec,
+    include_package: bool,
+    attach_package: bool | None = None,
+) -> ExecutionPlan:
+    steps: list[ExecutionStep] = []
+    attach_package = include_package if attach_package is None else attach_package
+    if include_package:
+        steps.append(ExecutionStep("package.create", "package", spec.package.name or spec.solution_name, "创建应用包"))
+    for role in spec.roles:
+        dependencies = ["package.create"] if include_package else []
+        steps.append(ExecutionStep(f"role.create.{role.role_id}", "role", role.role_id, f"创建角色 {role.name}", dependencies))
+    for entity in spec.entities:
+        entity_ref = entity.entity_id
+        dependencies = ["package.create"] if include_package else []
+        steps.append(ExecutionStep(f"app.create.{entity_ref}", "app", entity_ref, f"创建应用 {entity.display_name}", dependencies.copy()))
+        last_form_step = f"app.create.{entity_ref}"
+        if attach_package:
+            steps.append(
+                ExecutionStep(
+                    f"package.attach.{entity_ref}",
+                    "package_attach",
+                    entity_ref,
+                    f"将应用加入应用包 {entity.display_name}",
+                    [f"app.create.{entity_ref}"],
+                )
+            )
+            last_form_step = f"package.attach.{entity_ref}"
+        steps.append(ExecutionStep(f"form.base.{entity_ref}", "form", entity_ref, f"写入基础表单 {entity.display_name}", [last_form_step]))
+        last_form_step = f"form.base.{entity_ref}"
+        if any(field.type.value == "relation" for field in entity.fields):
+            steps.append(ExecutionStep(f"form.relations.{entity_ref}", "form", entity_ref, f"回填关联字段 {entity.display_name}", [f"form.base.{entity_ref}"]))
+            last_form_step = f"form.relations.{entity_ref}"
+        steps.append(ExecutionStep(f"publish.form.{entity_ref}", "app_publish", entity_ref, f"发布表单 {entity.display_name}", [last_form_step]))
+
+        last_app_step = f"publish.form.{entity_ref}"
+        if entity.workflow and entity.workflow.enabled:
+            workflow_dependencies = [last_app_step]
+            workflow_dependencies.extend(f"role.create.{role_ref}" for role_ref in _collect_workflow_role_refs(entity))
+            steps.append(ExecutionStep(f"workflow.{entity_ref}", "workflow", entity_ref, f"搭建流程 {entity.display_name}", workflow_dependencies))
+            steps.append(ExecutionStep(f"publish.workflow.{entity_ref}", "app_publish", entity_ref, f"发布流程 {entity.display_name}", [f"workflow.{entity_ref}"]))
+            last_app_step = f"publish.workflow.{entity_ref}"
+        publish_app_dependencies: list[str] = []
+        if entity.views:
+            steps.append(ExecutionStep(f"views.{entity_ref}", "view", entity_ref, f"搭建视图 {entity.display_name}", [last_app_step]))
+            publish_app_dependencies.append(f"views.{entity_ref}")
+        if entity.charts:
+            steps.append(ExecutionStep(f"charts.{entity_ref}", "chart", entity_ref, f"搭建报表 {entity.display_name}", [last_app_step]))
+            publish_app_dependencies.append(f"charts.{entity_ref}")
+        if not publish_app_dependencies:
+            publish_app_dependencies.append(last_app_step)
+        steps.append(ExecutionStep(f"publish.app.{entity_ref}", "app_publish", entity_ref, f"发布应用 {entity.display_name}", publish_app_dependencies))
+        if entity.sample_records:
+            seed_dependencies = [f"publish.app.{entity_ref}"]
+            seed_dependencies.extend(f"seed_data.{target_entity_id}" for target_entity_id in _collect_seed_dependencies(entity) if target_entity_id != entity.entity_id)
+            steps.append(ExecutionStep(f"seed_data.{entity_ref}", "record", entity_ref, f"写入模拟数据 {entity.display_name}", seed_dependencies))
+    if _should_create_portal(spec):
+        deps = [_entity_terminal_step(entity) for entity in spec.entities]
+        steps.append(ExecutionStep("portal.create", "portal", spec.portal.name or f"{spec.solution_name} 首页", "创建门户", deps))
+        steps.append(ExecutionStep("publish.portal", "portal_publish", spec.portal.name or f"{spec.solution_name} 首页", "发布门户", ["portal.create"]))
+    if _should_create_navigation(spec):
+        deps = [_entity_terminal_step(entity) for entity in spec.entities]
+        if _should_create_portal(spec):
+            deps.append("publish.portal")
+        steps.append(ExecutionStep("navigation.create", "navigation", spec.solution_name, "创建导航", deps))
+        steps.append(ExecutionStep("publish.navigation", "navigation_publish", spec.solution_name, "发布导航", ["navigation.create"]))
+    return ExecutionPlan(steps=steps)
+
+
+def _should_create_portal(spec: SolutionSpec) -> bool:
+    return spec.preferences.create_portal and spec.portal.enabled and bool(spec.portal.sections)
+
+
+def _should_create_navigation(spec: SolutionSpec) -> bool:
+    return spec.preferences.create_navigation and spec.navigation.enabled and bool(spec.navigation.items)
+
+
+def _collect_workflow_role_refs(entity: EntitySpec) -> list[str]:
+    if entity.workflow is None:
+        return []
+    role_refs: list[str] = []
+    for node in entity.workflow.nodes:
+        role_refs.extend(node.assignees.get("role_refs", []))
+    return list(dict.fromkeys(role_refs))
+
+
+def _collect_seed_dependencies(entity: EntitySpec) -> list[str]:
+    target_entity_ids: list[str] = []
+    reference_fields = {field.field_id: field.target_entity_id for field in entity.fields if field.target_entity_id}
+    for record in entity.sample_records:
+        for field_id, value in record.values.items():
+            target_entity_id = reference_fields.get(field_id)
+            if not target_entity_id:
+                continue
+            if value is None:
+                continue
+            target_entity_ids.append(target_entity_id)
+    return list(dict.fromkeys(target_entity_ids))
+
+
+def _entity_terminal_step(entity: EntitySpec) -> str:
+    return f"seed_data.{entity.entity_id}" if entity.sample_records else f"publish.app.{entity.entity_id}"
+
+
+def _apply_portal_chart_semantics(spec: SolutionSpec, entities: list[CompiledEntity]) -> None:
+    if not _should_create_portal(spec):
+        return
+    portal_chart_refs = _collect_portal_chart_refs(spec)
+    if not portal_chart_refs:
+        return
+    for entity in entities:
+        for chart_plan in entity.chart_plans:
+            if (entity.entity_id, chart_plan["chart_id"]) not in portal_chart_refs:
+                continue
+            if chart_plan.get("preserve_portal_query_conditions"):
+                continue
+            chart_plan["config_payload"]["beforeAggregationFilterMatrix"] = []
+            chart_plan["config_payload"]["afterAggregationFilterMatrix"] = []
+            chart_plan["config_payload"]["queryConditionFieldIds"] = []
+            chart_plan["config_payload"]["queryConditionStatus"] = False
+            chart_plan["config_payload"]["queryConditionExact"] = False
+
+
+def _collect_portal_chart_refs(spec: SolutionSpec) -> set[tuple[str, str]]:
+    refs: set[tuple[str, str]] = set()
+    for section in spec.portal.sections:
+        if section.source_type == PortalSourceType.chart and section.entity_id and section.chart_id:
+            refs.add((section.entity_id, section.chart_id))
+            continue
+        if section.source_type != PortalSourceType.filter:
+            continue
+        filter_config = section.config.get("filterConfig", [])
+        graph_list = section.config.get("graphList", [])
+        if isinstance(filter_config, dict):
+            graph_list = filter_config.get("graphList", graph_list)
+            filter_config = filter_config.get("filterConfig", [])
+        refs.update(_collect_chart_refs_from_graphs(graph_list))
+        for group in filter_config or []:
+            for item in group.get("filterGroupConfig", []) or []:
+                refs.update(_collect_chart_refs_from_graphs(item.get("filterCondition", []) or []))
+    return refs
+
+
+def _collect_chart_refs_from_graphs(items: list[dict[str, Any]]) -> set[tuple[str, str]]:
+    refs: set[tuple[str, str]] = set()
+    for item in items:
+        graph_ref = item.get("graphRef") if isinstance(item.get("graphRef"), dict) else {}
+        entity_id = item.get("entity_id") or graph_ref.get("entity_id")
+        chart_id = item.get("chart_id") or graph_ref.get("chart_id")
+        if entity_id and chart_id:
+            refs.add((str(entity_id), str(chart_id)))
+    return refs

package/src/qingflow_mcp/solution/compiler/chart_compiler.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+from typing import Any
+
+from ..spec_models import ChartType, EntitySpec
+
+
+QINGBI_CHART_TYPE_MAP = {
+    ChartType.bar: "bar",
+    ChartType.line: "line",
+    ChartType.pie: "pie",
+    ChartType.summary: "indicator",
+    ChartType.data: "detail",
+    ChartType.target: "indicator",
+    ChartType.funnel: "funnel",
+}
+
+
+def qingbi_workspace_visible_auth() -> dict[str, Any]:
+    return {
+        "type": "ws",
+        "contactAuth": {
+            "type": "all",
+            "authMembers": {
+                "member": [],
+                "depart": [],
+                "role": [],
+                "includeSubDeparts": True,
+            },
+        },
+        "externalMemberAuth": {
+            "type": "not",
+            "authMembers": {
+                "member": [],
+                "depart": [],
+                "role": [],
+            },
+        },
+    }
+
+
+def compile_charts(entity: EntitySpec) -> list[dict[str, Any]]:
+    plans: list[dict[str, Any]] = []
+    field_labels = {field.field_id: field.label for field in entity.fields}
+    for ordinal, chart in enumerate(entity.charts, start=1):
+        config = dict(chart.config)
+        aggregate = config.pop("aggregate", "count")
+        after_filters = list(config.pop("after_aggregation_filters", []))
+        query_condition_field_ids = list(config.pop("query_condition_field_ids", []))
+        query_condition_status = bool(config.pop("query_condition_status", bool(query_condition_field_ids)))
+        query_condition_exact = bool(config.pop("query_condition_exact", False))
+        plans.append(
+            {
+                "chart_id": chart.chart_id,
+                "name": chart.name,
+                "chart_type": QINGBI_CHART_TYPE_MAP[chart.chart_type],
+                "preserve_portal_query_conditions": bool(chart.config.get("preserve_portal_query_conditions", False)),
+                "create_payload": {
+                    "chartId": "__BI_CHART_ID__",
+                    "chartName": chart.name,
+                    "chartType": QINGBI_CHART_TYPE_MAP[chart.chart_type],
+                    "dataSourceType": "qingflow",
+                    "tagId": "0",
+                    "parentId": "0",
+                    "dataSourceId": "__APP_KEY__",
+                    "visibleAuth": qingbi_workspace_visible_auth(),
+                    "editAuthList": [],
+                    "editAuthType": "ws",
+                    "editAuthIncludeSubDept": True,
+                },
+                "config_payload": {
+                    "chartName": chart.name,
+                    "chartType": QINGBI_CHART_TYPE_MAP[chart.chart_type],
+                    "selectedDimensionFieldIds": list(chart.dimension_field_ids),
+                    "selectedMetricFieldIds": list(chart.indicator_field_ids),
+                    "aggregate": aggregate,
+                    "beforeAggregationFilterMatrix": list(chart.filters),
+                    "afterAggregationFilterMatrix": after_filters,
+                    "queryConditionFieldIds": query_condition_field_ids,
+                    "queryConditionStatus": query_condition_status,
+                    "queryConditionExact": query_condition_exact,
+                    "displayLimitConfig": config.pop("displayLimitConfig", {"status": 1, "type": "asc", "limit": 20}),
+                    "rawDataConfigDTO": config.pop(
+                        "rawDataConfigDTO",
+                        {
+                            "beingOpen": False,
+                            "authInfo": qingbi_workspace_visible_auth(),
+                            "fieldInfoList": [],
+                        },
+                    ),
+                    **config,
+                },
+                "ordinal": ordinal,
+            }
+        )
+    return plans