feat(skill-compiler): skill compiler

api/core/app_assets/builder/__init__.py

@@ -0,0 +1,12 @@
+from .base import AssetBuilder, BuildContext
+from .file_builder import FileBuilder
+from .pipeline import AssetBuildPipeline
+from .skill_builder import SkillBuilder
+
+__all__ = [
+    "AssetBuildPipeline",
+    "AssetBuilder",
+    "BuildContext",
+    "FileBuilder",
+    "SkillBuilder",
+]

api/core/app_assets/builder/base.py

@@ -0,0 +1,20 @@
+from dataclasses import dataclass
+from typing import Protocol
+
+from core.app.entities.app_asset_entities import AppAssetFileTree, AppAssetNode
+from core.app_assets.entities import AssetItem
+
+
+@dataclass
+class BuildContext:
+    tenant_id: str
+    app_id: str
+    build_id: str
+
+
+class AssetBuilder(Protocol):
+    def accept(self, node: AppAssetNode) -> bool: ...
+
+    def collect(self, node: AppAssetNode, path: str, ctx: BuildContext) -> None: ...
+
+    def build(self, tree: AppAssetFileTree, ctx: BuildContext) -> list[AssetItem]: ...

api/core/app_assets/builder/file_builder.py

@@ -0,0 +1,30 @@
+from core.app.entities.app_asset_entities import AppAssetFileTree, AppAssetNode
+from core.app_assets.entities import AssetItem, FileAsset
+from core.app_assets.paths import AssetPaths
+
+from .base import BuildContext
+
+
+class FileBuilder:
+    _nodes: list[tuple[AppAssetNode, str]]
+
+    def __init__(self) -> None:
+        self._nodes = []
+
+    def accept(self, node: AppAssetNode) -> bool:
+        return True
+
+    def collect(self, node: AppAssetNode, path: str, ctx: BuildContext) -> None:
+        self._nodes.append((node, path))
+
+    def build(self, tree: AppAssetFileTree, ctx: BuildContext) -> list[AssetItem]:
+        return [
+            FileAsset(
+                asset_id=node.id,
+                path=path,
+                file_name=node.name,
+                extension=node.extension or "",
+                storage_key=AssetPaths.draft_file(ctx.tenant_id, ctx.app_id, node.id),
+            )
+            for node, path in self._nodes
+        ]

api/core/app_assets/builder/pipeline.py

@@ -0,0 +1,29 @@
+from core.app.entities.app_asset_entities import AppAssetFileTree
+from core.app_assets.builder.file_builder import FileBuilder
+from core.app_assets.builder.skill_builder import SkillBuilder
+from core.app_assets.entities import AssetItem
+
+from .base import AssetBuilder, BuildContext
+
+
+class AssetBuildPipeline:
+    _builders: list[AssetBuilder]
+
+    def __init__(self, builders: list[AssetBuilder] | None = None) -> None:
+        self._builders = builders or [SkillBuilder(), FileBuilder()]
+
+    def build_all(self, tree: AppAssetFileTree, ctx: BuildContext) -> list[AssetItem]:
+        # 1. Distribute: each node goes to first accepting builder
+        for node in tree.walk_files():
+            path = tree.get_path(node.id)
+            for builder in self._builders:
+                if builder.accept(node):
+                    builder.collect(node, path, ctx)
+                    break
+
+        # 2. Each builder builds its collected nodes
+        results: list[AssetItem] = []
+        for builder in self._builders:
+            results.extend(builder.build(tree, ctx))
+
+        return results

api/core/app_assets/builder/skill_builder.py

@@ -0,0 +1,85 @@
+import json
+
+from core.app.entities.app_asset_entities import AppAssetFileTree, AppAssetNode
+from core.app_assets.entities import AssetItem, FileAsset
+from core.app_assets.paths import AssetPaths
+from core.skill.entities.skill_document import SkillDocument
+from core.skill.skill_compiler import SkillCompiler
+from core.skill.skill_manager import SkillManager
+from extensions.ext_storage import storage
+
+from .base import BuildContext
+
+
+class SkillBuilder:
+    _nodes: list[tuple[AppAssetNode, str]]
+
+    def __init__(self) -> None:
+        self._nodes = []
+
+    def accept(self, node: AppAssetNode) -> bool:
+        return node.extension == "md"
+
+    def collect(self, node: AppAssetNode, path: str, ctx: BuildContext) -> None:
+        self._nodes.append((node, path))
+
+    def build(self, tree: AppAssetFileTree, ctx: BuildContext) -> list[AssetItem]:
+        if not self._nodes:
+            return []
+
+        # 1. Load and create documents
+        documents: list[SkillDocument] = []
+        for node, _ in self._nodes:
+            draft_key = AssetPaths.draft_file(ctx.tenant_id, ctx.app_id, node.id)
+            try:
+                data = json.loads(storage.load_once(draft_key))
+                content = data.get("content", "") if isinstance(data, dict) else ""
+                metadata = data.get("metadata", {}) if isinstance(data, dict) else {}
+            except Exception:
+                content = ""
+                metadata = {}
+
+            documents.append(
+                SkillDocument(
+                    skill_id=node.id,
+                    content=content,
+                    metadata=metadata,
+                )
+            )
+
+        # 2. Compile all skills
+        compiler = SkillCompiler()
+        artifact_set = compiler.compile_all(documents, tree, ctx.build_id)
+
+        # 3. Save tool artifact
+        SkillManager.save_tool_artifact(
+            ctx.tenant_id,
+            ctx.app_id,
+            ctx.build_id,
+            artifact_set.get_tool_artifact(),
+        )
+
+        # 4. Save compiled content to storage and return FileAssets
+        results: list[AssetItem] = []
+        for node, path in self._nodes:
+            artifact = artifact_set.get(node.id)
+            if artifact is None:
+                continue
+
+            # Write compiled content to storage
+            resolved_key = AssetPaths.build_resolved_file(
+                ctx.tenant_id, ctx.app_id, ctx.build_id, node.id
+            )
+            storage.save(resolved_key, artifact.content.encode("utf-8"))
+
+            results.append(
+                FileAsset(
+                    asset_id=node.id,
+                    path=path,
+                    file_name=node.name,
+                    extension=node.extension or "",
+                    storage_key=resolved_key,
+                )
+            )
+
+        return results