AIPodCli 0.1.0__py3-none-any.whl

ai_pod_cli/__init__.py

@@ -0,0 +1,7 @@
+"""AIPodCli - AI-native IoC container low-code engine CLI."""
+
+__version__ = "0.1.0"
+
+from ai_pod_cli.context import PipelineContext
+
+__all__ = ["PipelineContext"]

ai_pod_cli/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running as `python -m ai_pod_cli`."""
+
+from ai_pod_cli.cli import main
+
+main()

ai_pod_cli/cli.py

@@ -0,0 +1,65 @@
+"""CLI entry point — argparse setup and command dispatch."""
+
+import argparse
+import sys
+
+from ai_pod_cli.config import init_config_if_not_exists
+from ai_pod_cli.commands.add import handle_add
+from ai_pod_cli.commands.build import handle_build
+from ai_pod_cli.commands.create import handle_create
+from ai_pod_cli.commands.init import handle_init
+
+
+def main():
+    """Main CLI entry point for the AI Pod engine."""
+    # 从 .env 文件加载环境变量（优先于系统环境变量）
+    from dotenv import load_dotenv
+    load_dotenv()
+
+    # Windows 终端 GBK 兼容：强制 UTF-8 输出
+    if sys.stdout.encoding and sys.stdout.encoding.lower() != "utf-8":
+        sys.stdout.reconfigure(encoding="utf-8")
+    if sys.stderr.encoding and sys.stderr.encoding.lower() != "utf-8":
+        sys.stderr.reconfigure(encoding="utf-8")
+
+    # init 命令自行管理初始化，其余命令走自动初始化
+    if len(sys.argv) > 1 and sys.argv[1] != "init":
+        init_config_if_not_exists()
+
+    parser = argparse.ArgumentParser(description="AI 原生 IoC 容器低代码引擎 CLI")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    # 1. init 命令定义
+    init_parser = subparsers.add_parser("init", help="初始化项目：创建目录、配置，可选 AI 生成入口文件")
+    init_parser.add_argument("desc", nargs="?", default="", help="项目描述（AI 据此判断技术栈并生成入口文件）")
+    init_parser.add_argument("--install-deps", action="store_true", help="自动安装 Python 依赖")
+
+    # 2. create 命令定义
+    create_parser = subparsers.add_parser("create", help="让 AI 创造一个组件并记录配置")
+    create_parser.add_argument("--category", choices=["entry", "entity"], required=True, help="组件分类")
+    create_parser.add_argument("--name", required=True, help="组件名称")
+    create_parser.add_argument("--desc", required=True, help="给AI传入的需求和描述")
+
+    # 3. add 命令定义
+    add_parser = subparsers.add_parser("add", help="注册一个人工编写的实体组件到配置中心")
+    add_parser.add_argument("--category", choices=["entry", "entity"], default="entity", help="组件分类（默认 entity）")
+    add_parser.add_argument("--name", required=True, help="组件名称（必须与类名一致）")
+    add_parser.add_argument("--class-path", required=True, help="完整的类路径，如 mypackage.mymodule.MyClass")
+    add_parser.add_argument("--desc", required=True, help="组件功能描述")
+
+    # 4. build 命令定义
+    build_parser = subparsers.add_parser("build", help="AI 生成 pipeline 文件并注册到 routes.toml（只生成不执行）")
+    build_parser.add_argument("cmd", nargs="?", default="", help="自然语言业务指令（AI 据此规划执行链）")
+    build_parser.add_argument("--name", default="", help="保存 pipeline 的文件名（默认从指令自动生成）")
+    build_parser.add_argument("--list", action="store_true", help="列出所有已保存的 pipeline")
+
+    args = parser.parse_args()
+
+    if args.command == "init":
+        handle_init(args)
+    elif args.command == "create":
+        handle_create(args)
+    elif args.command == "add":
+        handle_add(args)
+    elif args.command == "build":
+        handle_build(args)

ai_pod_cli/client.py

@@ -0,0 +1,124 @@
+"""OpenAI client initialization with lazy loading and retry logic."""
+
+import json
+import os
+import time
+
+from openai import OpenAI
+
+
+_client: OpenAI | None = None
+_model: str | None = None
+
+# 默认重试配置
+DEFAULT_MAX_RETRIES = 3
+DEFAULT_RETRY_DELAY = 2  # 秒
+
+
+def get_client() -> OpenAI:
+    """Get or create the OpenAI client instance (lazy singleton).
+
+    Reads configuration from environment variables:
+      - OPENAI_API_KEY: API key (required)
+      - OPENAI_BASE_URL: API base URL (defaults to https://api.openai.com/v1)
+    """
+    global _client
+    if _client is None:
+        _client = OpenAI(
+            api_key=os.environ.get("OPENAI_API_KEY"),
+            base_url=os.environ.get("OPENAI_BASE_URL", "https://api.openai.com/v1"),
+        )
+    return _client
+
+
+def get_model() -> str:
+    """Get the model name from environment (defaults to deepseek-chat)."""
+    global _model
+    if _model is None:
+        _model = os.environ.get("OPENAI_MODEL", "deepseek-chat")
+    return _model
+
+
+def call_llm(
+    system_prompt: str,
+    user_content: str,
+    *,
+    json_mode: bool = False,
+    temperature: float = 0.1,
+    max_retries: int = DEFAULT_MAX_RETRIES,
+    retry_delay: float = DEFAULT_RETRY_DELAY,
+) -> dict | str:
+    """Call the LLM with retry on network errors or invalid JSON.
+
+    Args:
+        system_prompt: System prompt for the model.
+        user_content: User message content.
+        json_mode: If True, forces JSON output and parses the result into a dict.
+        temperature: Sampling temperature.
+        max_retries: Maximum number of retry attempts (default 3).
+        retry_delay: Base delay in seconds between retries (doubles each attempt).
+
+    Returns:
+        Parsed dict if json_mode=True, otherwise raw string content.
+
+    Raises:
+        RuntimeError: If all retries are exhausted.
+    """
+    client = get_client()
+    model = get_model()
+
+    kwargs = {
+        "model": model,
+        "messages": [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_content},
+        ],
+        "temperature": temperature,
+    }
+    if json_mode:
+        kwargs["response_format"] = {"type": "json_object"}
+
+    last_error: Exception | None = None
+    delay = retry_delay
+
+    for attempt in range(1, max_retries + 1):
+        try:
+            if attempt > 1:
+                print(f"   [retry] 第 {attempt}/{max_retries} 次重试...")
+
+            response = client.chat.completions.create(**kwargs)
+            raw_content = response.choices[0].message.content
+
+            if json_mode:
+                # 尝试解析 JSON
+                try:
+                    result = json.loads(raw_content)
+                except (json.JSONDecodeError, TypeError) as e:
+                    last_error = ValueError(f"AI 返回的内容不是合法 JSON: {e}\n原始内容: {raw_content[:300]}")
+                    print(f"   [retry] 第 {attempt} 次: JSON 解析失败")
+                    if attempt < max_retries:
+                        time.sleep(delay)
+                        delay *= 2
+                    continue
+
+                # 检查 code 字段是否为空（仅 create/start 场景）
+                if "code" in result and not result.get("code", "").strip():
+                    last_error = ValueError("AI 返回的 code 字段为空")
+                    print(f"   [retry] 第 {attempt} 次: code 字段为空")
+                    if attempt < max_retries:
+                        time.sleep(delay)
+                        delay *= 2
+                    continue
+
+                return result
+
+            return raw_content
+
+        except Exception as e:
+            last_error = e
+            print(f"   [retry] 第 {attempt} 次: API 调用失败 ({type(e).__name__})")
+            if attempt < max_retries:
+                time.sleep(delay)
+                delay *= 2
+
+    raise RuntimeError(f"LLM 调用在 {max_retries} 次重试后仍然失败: {last_error}")

ai_pod_cli/commands/__init__.py

@@ -0,0 +1 @@
+"""CLI command implementations."""

ai_pod_cli/commands/add.py

@@ -0,0 +1,28 @@
+"""`add` command — register a human-written entity into the bean config."""
+
+from ai_pod_cli.config import load_config, save_config
+
+
+def handle_add(args):
+    """【add 命令】将人工编写的实体组件注册到配置中心"""
+    print(f"📦 [CLI] 正在注册人工实体: '{args.name}'...")
+
+    config = load_config()
+
+    # 检查是否已存在同名组件，存在则覆盖
+    config["beans"] = [b for b in config["beans"] if b["id"] != args.name]
+
+    new_bean = {
+        "id": args.name,
+        "category": args.category,
+        "type": "human_added",
+        "class_path": args.class_path,
+        "description": args.desc,
+    }
+
+    config["beans"].append(new_bean)
+    save_config(config)
+
+    print(f"💾 [注册成功] 实体 '{args.name}' 已写入配置中心 (class_path: {args.class_path})")
+    print(f"   分类: {args.category}")
+    print(f"   描述: {args.desc}")

ai_pod_cli/commands/build.py

@@ -0,0 +1,226 @@
+"""`build` command — AI generates pipeline file and registers it in routes.toml."""
+
+import json
+import os
+import re
+from datetime import datetime
+
+from ai_pod_cli.client import call_llm
+from ai_pod_cli.config import (
+    load_config, load_config_toml_keys, PIPELINES_DIR, register_route,
+)
+from ai_pod_cli.security import validate_code
+
+
+def _slugify(text: str) -> str:
+    """将中文或任意文本转为安全的文件名。"""
+    safe = re.sub(r'[^\w一-鿿]+', '_', text.strip())
+    return safe[:60] or "pipeline"
+
+
+def _save_pipeline(code: str, name: str, instruction: str) -> str:
+    """将 AI 生成的 pipeline Python 代码保存到 pipelines/ 目录。"""
+    os.makedirs(PIPELINES_DIR, exist_ok=True)
+    filename = f"{name}.py"
+    filepath = os.path.join(PIPELINES_DIR, filename)
+
+    header = (
+        f'"""Pipeline: {instruction}\n'
+        f'Generated: {datetime.now().isoformat()}\n'
+        f'"""'
+    )
+    full_code = header + "\n\n" + code
+
+    with open(filepath, "w", encoding="utf-8") as f:
+        f.write(full_code)
+
+    return filepath
+
+
+def _list_pipelines() -> list[dict]:
+    """列出所有已保存的 pipeline (.py 文件)。"""
+    if not os.path.exists(PIPELINES_DIR):
+        return []
+
+    pipelines = []
+    for f in sorted(os.listdir(PIPELINES_DIR)):
+        if f == "__init__.py":
+            continue
+
+        filepath = os.path.join(PIPELINES_DIR, f)
+
+        if f.endswith(".py"):
+            instruction = ""
+            try:
+                with open(filepath, "r", encoding="utf-8") as fh:
+                    first_lines = "".join(fh.readline() for _ in range(3))
+                match = re.search(r'Pipeline:\s*(.+)', first_lines)
+                if match:
+                    instruction = match.group(1).strip()
+            except Exception:
+                pass
+
+            pipelines.append({
+                "file": f,
+                "name": f.replace(".py", ""),
+                "instruction": instruction,
+            })
+
+    return pipelines
+
+
+def handle_build(args):
+    """【build 命令】AI 编排器：生成 pipeline 文件 → 注册到 routes.toml"""
+
+    # --- --list: 列出所有已保存的 pipeline ---
+    if args.list:
+        pipelines = _list_pipelines()
+        if not pipelines:
+            print(f"📂 {PIPELINES_DIR}/ 目录为空，还没有保存任何 pipeline。")
+            return
+
+        print(f"📂 已保存的 Pipeline ({len(pipelines)} 条):\n")
+        for p in pipelines:
+            print(f"   🐍 {p['file']}")
+            print(f"      指令: {p['instruction']}")
+            print()
+        return
+
+    # --- 默认: AI 生成新的 Python pipeline ---
+    if not args.cmd:
+        print("❌ 请提供指令描述。")
+        return
+
+    print(f"🎬 [build] 人类宏观指令: '{args.cmd}'")
+
+    config = load_config()
+    existing_beans_context = json.dumps(config["beans"], indent=2, ensure_ascii=False)
+    toml_keys = load_config_toml_keys()
+
+    # 收集所有组件的 class_path 用于生成 import
+    component_imports = {}
+    for bean in config["beans"]:
+        cid = bean["id"]
+        cpath = bean["class_path"]
+        module_path, class_name = cpath.rsplit(".", 1)
+        component_imports[cid] = {"module": module_path, "class": class_name}
+
+    imports_hint = "\n".join(
+        f"    - {cid}: from {info['module']} import {info['class']}"
+        for cid, info in component_imports.items()
+    )
+
+    system_prompt = f"""
+    你是一个智能编排引擎。当前系统中注册了以下组件账本：
+    {existing_beans_context}
+
+    各组件的 import 路径：
+    {imports_hint}
+
+    当前 config.toml 中可用的配置段和键名：
+    {toml_keys}
+    组件通过注入 ConfigStore（from ai_pod_cli.config_store import ConfigStore）并用 config_store.get("section.key", default) 读取配置。
+
+    你的任务是：根据人类的自然语言指令，生成一个完整的 Python pipeline 脚本。
+
+    【生成的代码规范】：
+    1. 必须定义一个 `run(ctx)` 函数作为入口，ctx 是 PipelineContext 类型。
+    2. 在 run 函数内部：
+       - 从 ai_pod_cli.config import load_config
+       - 从 ai_pod_cli.container import build_container, Pod
+       - 用 build_container(config) 构建 DI 容器
+       - 用 S = Pod(container) 创建管道包装器
+       - 用 S(ComponentClass) 获取可管道串联的组件引用
+    3. 使用管道符 | 串联组件：
+       (S(组件A) | S(组件B)).execute_all(ctx)
+       这会自动依次执行各组件并记录轨迹。
+    4. 从 ctx.params 读取入口参数，通过 ctx.set() 传递数据。
+    5. 需要条件分支时，用 if/else 分别串联不同的管道。
+    6. 最后 return ctx.summary()。
+    7. 加上清晰的中文注释。
+
+    【PipelineContext 的 API】：
+    - ctx.params: dict — 入口参数
+    - ctx.set(key, value): 写入数据池
+    - ctx.get(key, default=None): 读取数据池
+    - ctx.record_step(component_id, result): 记录执行步骤
+    - ctx.summary(): 返回执行摘要 dict
+
+    【代码模板示例】：
+    ```python
+    from ai_pod_cli.context import PipelineContext
+    from ai_pod_cli.config import load_config
+    from ai_pod_cli.container import build_container, Pod
+    from modules.stockchecker import StockChecker
+    from modules.stocknotifier import StockNotifier
+
+
+    def run(ctx: PipelineContext):
+        config = load_config()
+        container = build_container(config)
+        S = Pod(container)
+
+        # 步骤 1: 检查库存
+        (S(StockChecker)).execute_all(ctx)
+
+        # 条件分支：库存不足时通知管理员
+        if ctx.get("stock", 0) <= 0:
+            (S(StockNotifier)).execute_all(ctx)
+
+        return ctx.summary()
+    ```
+
+    【多组件串联示例】：
+    ```python
+    # 依次执行 A → B → C（自动记录每步轨迹）
+    (S(ComponentA) | S(ComponentB) | S(ComponentC)).execute_all(ctx)
+    ```
+
+    请严格以标准 JSON 格式返回（不要包含 Markdown 块标记）：
+    {{
+        "pipeline_ids": ["组件ID_1", "组件ID_2"],
+        "code": "完整的 Python pipeline 脚本代码（只包含代码，不含 ```python 标记）"
+    }}
+    """
+
+    try:
+        result = call_llm(system_prompt, f"指令: {args.cmd}", json_mode=True, temperature=0.1)
+
+        pipeline_ids = result.get("pipeline_ids", [])
+        generated_code = result.get("code", "")
+
+        print(f"🔗 [AI 编排] 执行链: {' → '.join(pipeline_ids) if pipeline_ids else '(空)'}")
+
+        if not generated_code:
+            print("❌ AI 未返回有效代码。")
+            return
+
+    except Exception as e:
+        print(f"❌ AI 编排失败: {e}")
+        return
+
+    # 安全检查
+    violations = validate_code(generated_code, for_pipeline=True)
+    if violations:
+        print(f"🛡️  [安全检查失败] Pipeline 代码包含 {len(violations)} 处违规:")
+        for v in violations:
+            print(f"   ❌ {v}")
+        print(f"\n   Pipeline 未保存。请调整描述重试。")
+        return
+    print(f"🛡️  [安全检查通过]")
+
+    # 保存 pipeline 文件
+    name = args.name or _slugify(args.cmd)
+    filepath = _save_pipeline(generated_code, name, args.cmd)
+    print(f"💾 [Pipeline 已保存] {filepath}")
+
+    # 注册到 routes.toml
+    register_route(
+        name=name,
+        pipeline_path=filepath,
+        description=args.cmd,
+    )
+    print(f"📋 [路由已注册] {name} → {filepath}")
+
+    print(f"\n🎉 [build 完成] Pipeline 已生成并注册。")
+    print(f"   运行方式: 通过你的入口文件调用 PipelineRunner().run(\"{name}\", params)")