lingflow-plus 0.1.0__tar.gz

lingflow_plus-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 灵字辈 (Ling) Ecosystem
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lingflow_plus-0.1.0/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.1
+Name: lingflow-plus
+Version: 0.1.0
+Summary: LingFlow+ — Multi-project parallel CLI Agent for 灵字辈 ecosystem
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: lingflow
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4; extra == "dev"
+Requires-Dist: pytest-cov>=4.1; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+
+# LingFlow+
+
+灵字辈生态系统的多项目并行 CLI Agent。
+
+## 设计宪章
+
+**轻框架，多工具。重流程，重协调，重约束，重验证。和谐欢畅，自然端庄。**
+
+## 架构
+
+```
+LingFlow+ (集成层, ~800 行)
+├── project_manager.py   项目注册、Git 状态、会话绑定
+├── scheduler.py         跨项目并行调度（复用 LingFlow WorkflowOrchestrator）
+├── constraints.py       TokenQuota + RateLimiter + FileLock + ContextBudget
+├── tool_router.py       任务类型 → Agent 路由（MCP 协议）
+├── quality_gate.py      提交前质量门
+├── coordinator.py       主协调器（组合所有子系统）
+└── cli.py               CLI 入口（+run, +status, +projects, +dashboard, +review）
+```
+
+## 依赖
+
+- `lingflow` — 工作流引擎
+- `pyyaml` — YAML 工作流加载
+
+## 安装
+
+```bash
+pip install -e .
+```
+
+## 使用
+
+```bash
+# 注册项目
+lingflow-plus register LingFlow /home/ai/LingFlow
+lingflow-plus register LingClaude /home/ai/LingClaude
+
+# 查看所有项目
+lingflow-plus projects
+
+# 看板
+lingflow-plus dashboard
+
+# 执行跨项目工作流
+lingflow-plus run workflow.yaml
+
+# 质量门检查
+lingflow-plus review src/main.py tests/test_main.py
+
+# 全局状态
+lingflow-plus status
+```
+
+## 测试
+
+```bash
+pytest tests/ -v
+```

lingflow_plus-0.1.0/README.md

@@ -0,0 +1,60 @@
+# LingFlow+
+
+灵字辈生态系统的多项目并行 CLI Agent。
+
+## 设计宪章
+
+**轻框架，多工具。重流程，重协调，重约束，重验证。和谐欢畅，自然端庄。**
+
+## 架构
+
+```
+LingFlow+ (集成层, ~800 行)
+├── project_manager.py   项目注册、Git 状态、会话绑定
+├── scheduler.py         跨项目并行调度（复用 LingFlow WorkflowOrchestrator）
+├── constraints.py       TokenQuota + RateLimiter + FileLock + ContextBudget
+├── tool_router.py       任务类型 → Agent 路由（MCP 协议）
+├── quality_gate.py      提交前质量门
+├── coordinator.py       主协调器（组合所有子系统）
+└── cli.py               CLI 入口（+run, +status, +projects, +dashboard, +review）
+```
+
+## 依赖
+
+- `lingflow` — 工作流引擎
+- `pyyaml` — YAML 工作流加载
+
+## 安装
+
+```bash
+pip install -e .
+```
+
+## 使用
+
+```bash
+# 注册项目
+lingflow-plus register LingFlow /home/ai/LingFlow
+lingflow-plus register LingClaude /home/ai/LingClaude
+
+# 查看所有项目
+lingflow-plus projects
+
+# 看板
+lingflow-plus dashboard
+
+# 执行跨项目工作流
+lingflow-plus run workflow.yaml
+
+# 质量门检查
+lingflow-plus review src/main.py tests/test_main.py
+
+# 全局状态
+lingflow-plus status
+```
+
+## 测试
+
+```bash
+pytest tests/ -v
+```

lingflow_plus-0.1.0/lingflow_plus/__init__.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+"""LingFlow+ — Multi-project parallel CLI Agent
+
+灵字辈生态系统的多项目并行协调器。
+"""
+
+__version__ = "0.1.0"

lingflow_plus-0.1.0/lingflow_plus/cli.py

@@ -0,0 +1,160 @@
+from __future__ import annotations
+"""LingFlow+ CLI 入口
+
+命令：
+    +run <workflow.yaml>    执行跨项目工作流
+    +status                 查看全局状态
+    +projects               列出注册的项目
+    +register <name> <path> 注册项目
+    +unregister <name>      取消注册
+    +dashboard              看板（所有项目状态）
+    +review <files...>      质量门检查
+    +version                版本信息
+"""
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import List, Optional
+
+from lingflow_plus import __version__
+from lingflow_plus.coordinator import LingFlowPlus
+
+
+def cmd_status(args: argparse.Namespace) -> None:
+    """查看全局状态"""
+    lf = LingFlowPlus()
+    status = lf.status()
+    print(json.dumps(status, indent=2, ensure_ascii=False, default=str))
+
+
+def cmd_projects(args: argparse.Namespace) -> None:
+    """列出所有项目"""
+    lf = LingFlowPlus()
+    projects = lf.project_manager.list()
+    if not projects:
+        print("No projects registered.")
+        return
+    for p in projects:
+        git = p.git_status()
+        session = p.terminal_session or "-"
+        print(f"  {p.name:20s} {git.get('branch', '?'):15s} dirty={git.get('dirty_files', 0):3d} session={session}")
+        if p.description:
+            print(f"  {'':20s} {p.description}")
+
+
+def cmd_register(args: argparse.Namespace) -> None:
+    """注册项目"""
+    lf = LingFlowPlus()
+    path = str(Path(args.path).resolve())
+    ctx = lf.project_manager.register(args.name, path, description=args.description or "")
+    print(f"Registered: {ctx.name} -> {ctx.path}")
+
+
+def cmd_unregister(args: argparse.Namespace) -> None:
+    """取消注册"""
+    lf = LingFlowPlus()
+    if lf.project_manager.unregister(args.name):
+        print(f"Unregistered: {args.name}")
+    else:
+        print(f"Project not found: {args.name}")
+
+
+def cmd_dashboard(args: argparse.Namespace) -> None:
+    """看板"""
+    lf = LingFlowPlus()
+    dash = lf.project_manager.dashboard()
+    for item in dash:
+        name = item.get("name", "?")
+        git = item.get("git", {})
+        valid = item.get("valid", False)
+        branch = git.get("branch", "?")
+        dirty = git.get("dirty_files", 0)
+        status_mark = "✓" if valid else "✗"
+        print(f"  [{status_mark}] {name:20s} branch={branch:15s} dirty={dirty}")
+    token_status = lf.token_quota.get_status()
+    print(f"\n  Token: {token_status['window_used']:,} / {token_status['window_total']:,} used")
+
+
+def cmd_run(args: argparse.Namespace) -> None:
+    """执行工作流"""
+    lf = LingFlowPlus()
+    filepath = args.workflow
+    if not Path(filepath).exists():
+        print(f"File not found: {filepath}")
+        sys.exit(1)
+    print(f"Loading workflow: {filepath}")
+    results = lf.run_workflow_file(filepath)
+    success = sum(1 for r in results.values() if r.success)
+    failed = sum(1 for r in results.values() if not r.success)
+    print(f"Done: {success} success, {failed} failed, {len(results)} total")
+
+
+def cmd_review(args: argparse.Namespace) -> None:
+    """质量门检查"""
+    lf = LingFlowPlus()
+    report = lf.quality_check(args.files)
+    print(f"Score: {report.score}/100")
+    print(f"Gate: {'PASSED' if report.passed else 'BLOCKED'}")
+    if report.critical_issues:
+        print("\nCritical issues:")
+        for issue in report.critical_issues:
+            print(f"  ✗ {issue}")
+    if report.warnings:
+        print("\nWarnings:")
+        for w in report.warnings:
+            print(f"  ⚠ {w}")
+
+
+def cmd_version(args: argparse.Namespace) -> None:
+    """版本信息"""
+    print(f"LingFlow+ v{__version__}")
+
+
+def main(argv: Optional[List[str]] = None) -> None:
+    parser = argparse.ArgumentParser(
+        prog="lingflow-plus",
+        description="LingFlow+ — 灵字辈多项目并行 CLI Agent",
+    )
+    sub = parser.add_subparsers(dest="command")
+
+    p_run = sub.add_parser("run", help="Execute cross-project workflow")
+    p_run.add_argument("workflow", help="YAML workflow file")
+    p_run.set_defaults(func=cmd_run)
+
+    p_status = sub.add_parser("status", help="Global status")
+    p_status.set_defaults(func=cmd_status)
+
+    p_projects = sub.add_parser("projects", help="List projects")
+    p_projects.set_defaults(func=cmd_projects)
+
+    p_register = sub.add_parser("register", help="Register project")
+    p_register.add_argument("name", help="Project alias")
+    p_register.add_argument("path", help="Project directory")
+    p_register.add_argument("--description", "-d", default="", help="Description")
+    p_register.set_defaults(func=cmd_register)
+
+    p_unregister = sub.add_parser("unregister", help="Unregister project")
+    p_unregister.add_argument("name", help="Project alias")
+    p_unregister.set_defaults(func=cmd_unregister)
+
+    p_dashboard = sub.add_parser("dashboard", help="Dashboard view")
+    p_dashboard.set_defaults(func=cmd_dashboard)
+
+    p_review = sub.add_parser("review", help="Quality gate check")
+    p_review.add_argument("files", nargs="+", help="Files to check")
+    p_review.set_defaults(func=cmd_review)
+
+    p_version = sub.add_parser("version", help="Version info")
+    p_version.set_defaults(func=cmd_version)
+
+    args = parser.parse_args(argv)
+    if not hasattr(args, "func"):
+        parser.print_help()
+        sys.exit(0)
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

lingflow_plus-0.1.0/lingflow_plus/constraints.py

@@ -0,0 +1,267 @@
+from __future__ import annotations
+"""约束层
+
+TokenQuota、RateLimiter、FileLock、ContextBudget 四大约束。
+确保多项目并行执行时的资源安全。
+"""
+
+import fcntl
+import json
+import logging
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from threading import Lock
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+LOCKS_DIR = Path.home() / ".lingflow-plus" / "locks"
+STATE_PATH = Path.home() / ".lingflow-plus" / "state.json"
+
+
+@dataclass
+class TokenBudget:
+    """单项目 token 预算"""
+    project: str
+    allocated: int = 0
+    used: int = 0
+
+    @property
+    def remaining(self) -> int:
+        return max(0, self.allocated - self.used)
+
+    @property
+    def usage_ratio(self) -> float:
+        return self.used / self.allocated if self.allocated > 0 else 0.0
+
+
+class TokenQuotaManager:
+    """GLM API Token 配额管理器
+
+    跟踪 5 小时窗口内的 token 消耗，按项目分配预算。
+    """
+
+    def __init__(self, window_tokens: int = 5_000_000, window_seconds: int = 18000):
+        self.window_tokens = window_tokens
+        self.window_seconds = window_seconds
+        self._budgets: Dict[str, TokenBudget] = {}
+        self._lock = Lock()
+        self._window_start = time.time()
+        self._total_used = 0
+
+    def allocate(self, project: str, tokens: int) -> TokenBudget:
+        """为项目分配 token 预算"""
+        with self._lock:
+            self._check_window_reset()
+            budget = TokenBudget(project=project, allocated=tokens)
+            self._budgets[project] = budget
+            logger.info(f"Allocated {tokens} tokens for {project}")
+            return budget
+
+    def consume(self, project: str, tokens: int) -> bool:
+        """消耗 token，返回是否成功（超预算返回 False）"""
+        with self._lock:
+            self._check_window_reset()
+            budget = self._budgets.get(project)
+            if not budget:
+                logger.warning(f"No budget for project {project}")
+                return False
+            if budget.remaining < tokens:
+                logger.warning(f"Token budget exhausted for {project}: {budget.remaining} < {tokens}")
+                return False
+            budget.used += tokens
+            self._total_used += tokens
+            return True
+
+    def get_status(self) -> Dict[str, Any]:
+        """获取配额状态"""
+        with self._lock:
+            self._check_window_reset()
+            return {
+                "window_total": self.window_tokens,
+                "window_used": self._total_used,
+                "window_remaining": self.window_tokens - self._total_used,
+                "window_elapsed": round(time.time() - self._window_start, 1),
+                "projects": {name: {"allocated": b.allocated, "used": b.used, "remaining": b.remaining}
+                             for name, b in self._budgets.items()},
+            }
+
+    def _check_window_reset(self) -> None:
+        """检查是否需要重置窗口"""
+        if time.time() - self._window_start >= self.window_seconds:
+            self._window_start = time.time()
+            self._total_used = 0
+            for budget in self._budgets.values():
+                budget.used = 0
+
+
+class RateLimiter:
+    """请求速率限制器
+
+    指数退避 + 滑动窗口。
+    """
+
+    def __init__(self, max_rpm: int = 60, max_concurrent: int = 5):
+        self.max_rpm = max_rpm
+        self.max_concurrent = max_concurrent
+        self._timestamps: List[float] = []
+        self._active = 0
+        self._lock = Lock()
+        self._backoff_until: float = 0
+
+    def acquire(self) -> float:
+        """获取执行许可，返回需要等待的秒数"""
+        with self._lock:
+            now = time.time()
+            if now < self._backoff_until:
+                return self._backoff_until - now
+
+            self._timestamps = [t for t in self._timestamps if now - t < 60]
+            if len(self._timestamps) >= self.max_rpm:
+                wait = 60 - (now - self._timestamps[0]) + 0.1
+                return wait
+
+            if self._active >= self.max_concurrent:
+                return 0.5
+
+            self._timestamps.append(now)
+            self._active += 1
+            return 0.0
+
+    def release(self) -> None:
+        """释放执行许可"""
+        with self._lock:
+            self._active = max(0, self._active - 1)
+
+    def trigger_backoff(self, seconds: float = 30.0) -> None:
+        """触发退避（如收到 429 响应）"""
+        with self._lock:
+            self._backoff_until = time.time() + seconds
+            logger.warning(f"Rate limiter backoff triggered: {seconds}s")
+
+    def get_status(self) -> Dict[str, Any]:
+        """获取速率状态"""
+        with self._lock:
+            now = time.time()
+            recent = [t for t in self._timestamps if now - t < 60]
+            return {
+                "rpm_used": len(recent),
+                "rpm_limit": self.max_rpm,
+                "active_requests": self._active,
+                "max_concurrent": self.max_concurrent,
+                "backoff_remaining": max(0, self._backoff_until - now),
+            }
+
+
+class FileLock:
+    """基于 fcntl.flock 的文件级互斥锁
+
+    用于防止多个进程同时修改同一文件。
+    """
+
+    def __init__(self, locks_dir: Optional[str] = None):
+        self._locks_dir = Path(locks_dir) if locks_dir else LOCKS_DIR
+        self._locks_dir.mkdir(parents=True, exist_ok=True)
+        self._fd_map: Dict[str, Any] = {}
+
+    def acquire(self, filepath: str, timeout: float = 30.0) -> bool:
+        """获取文件锁"""
+        lock_path = str(self._locks_dir / _safe_lock_name(filepath))
+        start = time.time()
+        while time.time() - start < timeout:
+            try:
+                fd = open(lock_path, "w")
+                fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+                self._fd_map[filepath] = fd
+                return True
+            except (IOError, OSError):
+                try:
+                    fd.close()
+                except Exception:
+                    pass
+                time.sleep(0.1)
+        logger.warning(f"FileLock timeout for {filepath}")
+        return False
+
+    def release(self, filepath: str) -> None:
+        """释放文件锁"""
+        fd = self._fd_map.pop(filepath, None)
+        if fd is not None:
+            try:
+                fcntl.flock(fd, fcntl.LOCK_UN)
+                fd.close()
+            except (IOError, OSError):
+                pass
+
+    def is_locked(self, filepath: str) -> bool:
+        """检查文件是否被锁"""
+        lock_path = str(self._locks_dir / _safe_lock_name(filepath))
+        try:
+            fd = open(lock_path, "w")
+            fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+            fcntl.flock(fd, fcntl.LOCK_UN)
+            fd.close()
+            return False
+        except (IOError, OSError):
+            try:
+                fd.close()
+            except Exception:
+                pass
+            return True
+
+
+class ContextBudget:
+    """项目上下文预算管理
+
+    每个项目有独立上下文预算，超限时自动触发压缩。
+    """
+
+    def __init__(self, default_limit: int = 8000, compress_threshold: float = 0.85):
+        self.default_limit = default_limit
+        self.compress_threshold = compress_threshold
+        self._limits: Dict[str, int] = {}
+        self._usage: Dict[str, int] = {}
+
+    def set_limit(self, project: str, limit: int) -> None:
+        """设置项目上下文限制"""
+        self._limits[project] = limit
+
+    def get_limit(self, project: str) -> int:
+        """获取项目上下文限制"""
+        return self._limits.get(project, self.default_limit)
+
+    def track(self, project: str, tokens: int) -> None:
+        """记录 token 消耗"""
+        self._usage[project] = self._usage.get(project, 0) + tokens
+
+    def should_compress(self, project: str) -> bool:
+        """是否需要压缩上下文"""
+        usage = self._usage.get(project, 0)
+        limit = self.get_limit(project)
+        return usage >= limit * self.compress_threshold
+
+    def reset(self, project: str) -> None:
+        """重置项目上下文使用量"""
+        self._usage[project] = 0
+
+    def get_status(self) -> Dict[str, Dict[str, Any]]:
+        """获取所有项目上下文状态"""
+        result = {}
+        for project in set(list(self._limits.keys()) + list(self._usage.keys())):
+            limit = self.get_limit(project)
+            used = self._usage.get(project, 0)
+            result[project] = {
+                "limit": limit,
+                "used": used,
+                "remaining": max(0, limit - used),
+                "usage_ratio": round(used / limit, 3) if limit > 0 else 0,
+                "should_compress": used >= limit * self.compress_threshold,
+            }
+        return result
+
+
+def _safe_lock_name(filepath: str) -> str:
+    """将文件路径转换为安全的锁文件名"""
+    import hashlib
+    return hashlib.md5(filepath.encode()).hexdigest() + ".lock"