reglow-agent 0.6.1__py3-none-any.whl

reglow_agent/__init__.py

@@ -0,0 +1,64 @@
+"""reglow-agent —— Reglow AI-Native 生成能力（Python 附加产品包）
+
+不属于 reglow 基础库。基础库只承诺四语言同构的基础模块；
+本包是 AI-Native 产品的本体（Schema DSL / 生成引擎 / Agent 运行时 / 评测集）。
+
+挂载方式（业务侧显式挂载，基础库不含任何 agent 知识、也不反向依赖本包）：
+
+    import reglow_agent
+    from reglow.server import app
+
+    reglow_agent.register(app)   # 挂载 /admin/api/v1/agent/* 与 /schema_dsl/* 等路由
+"""
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from fastapi import FastAPI
+
+__version__ = "0.6.0"
+
+# 本包提供对外路由的模块包（相对 reglow 默认发现根是额外的根）
+ROUTER_ROOTS: list[str] = ["reglow_agent.modules"]
+
+__all__ = ["register", "register_models", "ROUTER_ROOTS", "__version__"]
+
+
+def register_models() -> None:
+    """把本包 ORM 模型注册进 Base.metadata。
+
+    基础库的 _import_all_models() 只含基础库表结构，因此调用方必须在
+    create_all()（或 _auto_init_database）之前调用本函数，否则本包的表
+    （如 sys_agent_audit / sys_agent_tool）不会被创建。
+    """
+    import reglow_agent.modules.agent_runtime.model  # noqa: F401
+
+
+def register(app: "FastAPI") -> None:
+    """把本包的模块路由挂载到给定应用，并注册本包 ORM 模型。
+
+    基础库的路由自动发现只扫描 reglow.modules 与 app.modules；本包位于
+    reglow_agent.modules，因此需要应用侧显式调用本函数完成挂载。
+    路径与标签约定复用基础库的 tooling，避免两处实现漂移。
+    """
+    from fastapi import APIRouter
+
+    from reglow.core.plugin import (
+        ADMIN_API_PREFIX,
+        CLIENT_API_PREFIX,
+        discover_client_routers,
+        discover_routers,
+        mount_admin_routers,
+        mount_client_routers,
+    )
+
+    register_models()
+
+    admin_api = APIRouter(prefix=ADMIN_API_PREFIX)
+    mount_admin_routers(admin_api, discover_routers(ROUTER_ROOTS))
+    app.include_router(admin_api)
+
+    client_api = APIRouter(prefix=CLIENT_API_PREFIX)
+    mount_client_routers(client_api, discover_client_routers(ROUTER_ROOTS))
+    app.include_router(client_api)

reglow_agent/agent/__init__.py

@@ -0,0 +1,28 @@
+"""AI-Native：生成引擎内核（agent）
+
+生成引擎 L1 = Schema DSL 输入 + 代码生成器（backend/frontend）+ 生成器注册表。
+与 agent_runtime（运行时）分离：此处是"开发时生成"，agent_runtime 是"运行时执行"。
+"""
+from .engine import (
+    BackendGenerator,
+    FrontendGenerator,
+    GenerationResult,
+    GeneratorRegistry,
+    build_backend_context,
+    generate_backend,
+    generate_frontend,
+    generate_module,
+    registry,
+)
+
+__all__ = [
+    "BackendGenerator",
+    "FrontendGenerator",
+    "GenerationResult",
+    "GeneratorRegistry",
+    "build_backend_context",
+    "generate_backend",
+    "generate_frontend",
+    "generate_module",
+    "registry",
+]

reglow_agent/agent/cli.py

@@ -0,0 +1,112 @@
+"""生成引擎 CLI（python -m reglow_agent.agent.cli）
+
+用法：
+    python -m reglow_agent.agent.cli validate schema.yaml            # 校验 Schema
+    python -m reglow_agent.agent.cli generate schema.yaml            # 生成后端（六层+迁移+种子，默认 ./generated）
+    python -m reglow_agent.agent.cli generate schema.yaml -o .       # 指定目标后端工程根目录
+    python -m reglow_agent.agent.cli generate schema.yaml -f src     # 同时生成前端（frontend-admin/src）
+"""
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from reglow_agent.agent.engine.runner import generate_backend, generate_module
+from reglow_agent.modules.schema_dsl.parser import parse_schema_text
+from reglow_agent.modules.schema_dsl.validator import SchemaValidationError, validate_schema
+
+
+def _load_schema(path: str):
+    return parse_schema_text(Path(path).read_text(encoding="utf-8"))
+
+
+def cmd_validate(args: argparse.Namespace) -> int:
+    data = _load_schema(args.schema_file)
+    issues = validate_schema(data)
+    if issues:
+        print(f"校验失败：{len(issues)} 处错误", file=sys.stderr)
+        for issue in issues:
+            print(f"  [{issue.path}] {issue.message}", file=sys.stderr)
+        return 1
+    module = data.get("module", "?")
+    fields = len(data.get("fields", []))
+    print(f"校验通过：module={module}，fields={fields}")
+    return 0
+
+
+def cmd_generate(args: argparse.Namespace) -> int:
+    data = _load_schema(args.schema_file)
+    if args.frontend_src:
+        result = generate_module(data, args.target_dir, args.frontend_src)
+        print(f"生成完成（前后端）：{result.module}（{result.total_lines} 行 / {len(result.files)} 个文件）")
+    else:
+        result = generate_backend(data, args.target_dir)
+        print(f"生成完成（后端）：{result.module}（{result.total_lines} 行 / {len(result.files)} 个文件）")
+    print(f"目标目录：{result.target_dir}")
+    return 0
+
+
+def cmd_analyze(args: argparse.Namespace) -> int:
+    """L2 需求对话：自然语言需求 → Schema DSL 或澄清问题"""
+    import asyncio
+
+    from reglow.core.database import AsyncSessionLocal
+    from reglow_agent.agent.engine.requirement_analyzer import RequirementAnalyzer
+
+    async def _run() -> dict:
+        async with AsyncSessionLocal() as db:
+            analyzer = RequirementAnalyzer(db, provider=args.provider, model=args.model)
+            return (await analyzer.generate_schema(args.requirement)).to_dict()
+
+    result = asyncio.run(_run())
+    if result["valid"]:
+        print(f"Schema 校验通过（provider={result['provider']}）")
+        print(result["schema_text"])
+        return 0
+    if result["questions"]:
+        print("需要澄清的问题：")
+        for i, q in enumerate(result["questions"], 1):
+            print(f"  {i}. {q}")
+        return 1
+    print("未能生成 Schema：", file=sys.stderr)
+    for issue in result["issues"]:
+        print(f"  {issue}", file=sys.stderr)
+    return 1
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="reglow-gen", description="Reglow 生成引擎 CLI")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    p_validate = sub.add_parser("validate", help="校验 Schema 文件")
+    p_validate.add_argument("schema_file", help="Schema YAML/JSON 文件路径")
+    p_validate.set_defaults(func=cmd_validate)
+
+    p_generate = sub.add_parser("generate", help="生成代码（后端默认，-f 时前后端一起）")
+    p_generate.add_argument("schema_file", help="Schema YAML/JSON 文件路径")
+    p_generate.add_argument("-o", "--target-dir", default="./generated", help="目标后端工程根目录（默认 ./generated）")
+    p_generate.add_argument("-f", "--frontend-src", default=None, help="目标前端 src 目录（提供则同时生成前端）")
+    p_generate.set_defaults(func=cmd_generate)
+
+    p_analyze = sub.add_parser("analyze", help="L2 需求对话：自然语言 → Schema DSL（或澄清问题）")
+    p_analyze.add_argument("requirement", help="自然语言需求描述（引号包裹）")
+    p_analyze.add_argument("--provider", default=None, help="LLM 服务商（默认取 ai 模块配置的 deepseek）")
+    p_analyze.add_argument("--model", default=None, help="模型名（默认取 provider 配置的 model）")
+    p_analyze.set_defaults(func=cmd_analyze)
+
+    args = parser.parse_args(argv)
+    try:
+        return args.func(args)
+    except SchemaValidationError as exc:
+        print(f"Schema 校验失败：{exc}", file=sys.stderr)
+        for issue in exc.issues:
+            print(f"  [{issue.path}] {issue.message}", file=sys.stderr)
+        return 1
+    except Exception as exc:  # noqa: BLE001
+        print(f"错误：{exc}", file=sys.stderr)
+        return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

reglow_agent/agent/engine/__init__.py

@@ -0,0 +1,27 @@
+"""生成引擎 L1 —— 后端六层 + Alembic 迁移 + 菜单/字典种子 + 前端页面生成
+
+Schema（ModuleSchema）→ backend（modules/{module}/ + alembic/versions/）→ frontend（views + api）。
+M1 只做后端六层；M2 补齐迁移、种子与前端页面（见《reglow-V1.0版本计划.md》）。
+"""
+from .backend_generator import BackendGenerator, build_backend_context, new_revision
+from .frontend_generator import FrontendGenerator
+from .registry import GeneratorRegistry, registry
+from .runner import (
+    GenerationResult,
+    generate_backend,
+    generate_frontend,
+    generate_module,
+)
+
+__all__ = [
+    "BackendGenerator",
+    "FrontendGenerator",
+    "GenerationResult",
+    "GeneratorRegistry",
+    "build_backend_context",
+    "generate_backend",
+    "generate_frontend",
+    "generate_module",
+    "new_revision",
+    "registry",
+]

reglow_agent/agent/engine/backend_generator.py

@@ -0,0 +1,108 @@
+"""后端生成器：Schema → 六层代码 + Alembic 迁移 + 菜单/字典种子"""
+from __future__ import annotations
+
+import logging
+from datetime import datetime
+from pathlib import Path
+
+from jinja2 import Environment, FileSystemLoader, TemplateNotFound
+
+from reglow_agent.modules.schema_dsl.models import ModuleSchema
+
+from .context import (
+    build_backend_context,
+    build_migration_context,
+    build_seed_context,
+    default_backend_templates_dir,
+)
+
+logger = logging.getLogger(__name__)
+
+# 六层文件名（模板 → 产物文件名）
+BACKEND_FILES: dict[str, str] = {
+    "__init__.py": "__init__.py",
+    "model.py": "model.py",
+    "schema.py": "schema.py",
+    "repository.py": "repository.py",
+    "service.py": "service.py",
+    "controller.py": "controller.py",
+    "router.py": "router.py",
+}
+
+
+def new_revision(module: str) -> str:
+    """生成 Alembic revision id（时间戳_模块名）"""
+    return datetime.now().strftime("%Y%m%d%H%M%S") + f"_{module}"
+
+
+class BackendGenerator:
+    """L1 后端生成器：ModuleSchema → 六层 + 迁移 + 种子"""
+
+    def __init__(self, templates_dir: Path | None = None):
+        self.templates_dir = templates_dir or default_backend_templates_dir()
+        if not self.templates_dir.is_dir():
+            raise FileNotFoundError(f"生成模板目录不存在: {self.templates_dir}")
+        self._env = Environment(
+            loader=FileSystemLoader(str(self.templates_dir)),
+            keep_trailing_newline=True,
+            trim_blocks=True,
+            lstrip_blocks=True,
+        )
+
+    def _render(self, template_name: str, **context) -> str:
+        try:
+            template = self._env.get_template(template_name)
+        except TemplateNotFound:
+            raise FileNotFoundError(f"模板缺失: {self.templates_dir / template_name}")
+        return template.render(**context)
+
+    def render(self, schema: ModuleSchema) -> dict[str, str]:
+        """渲染全部后端文件，返回 {逻辑名: 内容}"""
+        context = build_backend_context(schema)
+        rendered: dict[str, str] = {}
+        for template_name, file_name in BACKEND_FILES.items():
+            rendered[f"module/{file_name}"] = self._render(f"module/{template_name}.j2", **context)
+        return rendered
+
+    def render_migration(self, schema: ModuleSchema, revision: str | None = None,
+                         down_revision: str = "") -> tuple[str, str]:
+        """渲染 Alembic 迁移，返回 (revision, 内容)"""
+        revision = revision or new_revision(schema.module)
+        context = build_migration_context(schema, revision, down_revision)
+        return revision, self._render("migration/version.py.j2", **context)
+
+    def render_seed(self, schema: ModuleSchema) -> str:
+        """渲染菜单/字典种子脚本"""
+        return self._render("seed/seed.py.j2", **build_seed_context(schema))
+
+    def generate(self, schema: ModuleSchema, target_dir: Path,
+                 revision: str | None = None, down_revision: str = "") -> dict[str, Path]:
+        """渲染并写入：六层（modules/{module}/）+ 迁移（alembic/versions/）+ 种子（modules/{module}/seed.py）。
+
+        Returns:
+            {逻辑名: 绝对路径}
+        """
+        module_dir = target_dir / "modules" / schema.module
+        module_dir.mkdir(parents=True, exist_ok=True)
+        rendered = self.render(schema)
+        written: dict[str, Path] = {}
+        for logical, content in rendered.items():
+            file_path = module_dir / Path(logical).name
+            file_path.write_text(content, encoding="utf-8")
+            written[logical] = file_path
+
+        # 种子脚本
+        seed_path = module_dir / "seed.py"
+        seed_path.write_text(self.render_seed(schema), encoding="utf-8")
+        written["module/seed.py"] = seed_path
+
+        # Alembic 迁移
+        revision = revision or new_revision(schema.module)
+        versions_dir = target_dir / "alembic" / "versions"
+        versions_dir.mkdir(parents=True, exist_ok=True)
+        migration_path = versions_dir / f"{revision}.py"
+        migration_path.write_text(self.render_migration(schema, revision, down_revision)[1], encoding="utf-8")
+        written["migration"] = migration_path
+
+        logger.info("生成后端模块 %s → %s（%d 个文件 + 迁移）", schema.module, module_dir, len(written))
+        return written