dyro 0.1.0__py3-none-any.whl

dyro/__init__.py

@@ -0,0 +1,3 @@
+"""DyroEngineeringFlow: the dyro CLI for multi-repository delivery automation."""
+
+__version__ = "0.1.0"

dyro/__main__.py

@@ -0,0 +1,5 @@
+from .cli import main
+
+
+if __name__ == "__main__":
+    main()

dyro/cli.py

@@ -0,0 +1,529 @@
+from __future__ import annotations
+
+import argparse
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import os
+from pathlib import Path
+import shlex
+import sys
+import time
+
+from . import __version__
+from .config import CONFIG_NAME, Config, expand_argv, load, validate_id
+from .errors import DyroError
+from .onboarding import ask_for_workspace, bootstrap, render_config
+from .tasks import (
+    STATUSES,
+    answer_task,
+    board,
+    check_dispatchable,
+    decisions,
+    list_tasks,
+    load_task,
+    loop_tasks,
+    merge_task,
+    review_task,
+    run_gates,
+    run_task,
+    set_status,
+    stats,
+    status as task_status,
+    task_template,
+)
+from .workspace import create_line, doctor, get_line, line_root, list_lines, status_rows
+
+
+CONFIG_TEMPLATE = '''schema_version = 1
+
+[workspace]
+name = "{name}"
+
+[layout]
+anchors = "repositories"
+lines = "versions"
+hotfixes = "hotfixes"
+tasks = "worktrees"
+
+[policy]
+default_base = "main"
+task_branch_prefix = "task/"
+allow_push = false
+require_clean_merge = true
+
+# Commands are argv arrays, not shell strings.  DyroEngineeringFlow expands only
+# {{workspace}}, {{root}}, {{task}}, {{line}} and {{prompt}}.
+[adapters.codex]
+launch = ["codex", "-C", "{{workspace}}"]
+read = ["codex", "exec", "--skip-git-repo-check", "--sandbox", "workspace-write", "{{prompt}}"]
+write = ["codex", "exec", "--skip-git-repo-check", "--sandbox", "workspace-write", "{{prompt}}"]
+
+# Add each repository anchor once.  A release line or task receives linked
+# worktrees under the configured layout paths.
+[repositories.api]
+path = "repositories/services/api"
+mount = "services/api"
+verify = [["python3", "-m", "pytest", "-q"]]
+
+[repositories.web]
+path = "repositories/clients/web"
+mount = "clients/web"
+verify = [["npm", "test", "--", "--runInBand"]]
+'''
+
+
+def _config(args: argparse.Namespace) -> Config:
+    root = Path(args.root).expanduser() if getattr(args, "root", None) else Path.cwd()
+    return load(root)
+
+
+def _repositories(raw: str | None) -> list[str] | None:
+    if raw is None:
+        return None
+    values = [item.strip() for item in raw.split(",") if item.strip()]
+    if not values:
+        raise DyroError("--repos 不能为空")
+    return values
+
+
+def _require_yes(args: argparse.Namespace, label: str) -> None:
+    if not args.yes and not args.dry_run:
+        raise DyroError(f"{label} 会创建或修改 Git worktree；请先使用 --dry-run 检查，再加 --yes 执行")
+
+
+def _print_command(argv: tuple[str, ...]) -> None:
+    print("$ " + shlex.join(argv))
+
+
+def cmd_init(args: argparse.Namespace) -> None:
+    root = Path(args.path).expanduser().resolve()
+    config_file = root / CONFIG_NAME
+    if config_file.exists():
+        raise DyroError(f"配置已存在：{config_file}")
+    if args.dry_run:
+        print(f"DRY RUN: 将创建 {config_file}")
+        return
+    root.mkdir(parents=True, exist_ok=True)
+    if args.wizard:
+        name, repositories, base = ask_for_workspace(args.name)
+        content = render_config(name, repositories, base)
+    else:
+        content = CONFIG_TEMPLATE.format(name=args.name)
+    config_file.write_text(content, encoding="utf-8")
+    for relative in (".dyro/tasks", ".dyro/lines", ".dyro/hotfixes"):
+        (root / relative).mkdir(parents=True, exist_ok=True)
+    print(f"已初始化 {root}")
+    print("下一步：登记 repositories，随后运行 dyro doctor")
+
+
+def cmd_bootstrap(args: argparse.Namespace) -> None:
+    _require_yes(args, "bootstrap")
+    config = _config(args)
+    for message in bootstrap(config, dry_run=args.dry_run):
+        print(message)
+    if not args.dry_run:
+        for finding in doctor(config):
+            print(finding)
+
+
+def cmd_doctor(args: argparse.Namespace) -> None:
+    findings = doctor(_config(args))
+    for finding in findings:
+        print(finding)
+    if any(item.startswith("FAIL") for item in findings):
+        raise DyroError("doctor 发现结构错误")
+
+
+def cmd_status(args: argparse.Namespace) -> None:
+    rows = status_rows(_config(args))
+    print(f"{'SCOPE':24} {'REPOSITORY':14} {'BRANCH':24} {'HEAD':12} {'DIRTY':>5} UPSTREAM")
+    for scope, repo_id, branch, head, upstream, dirty in rows:
+        dirty_text = "-" if dirty < 0 else str(dirty)
+        print(f"{scope:24} {repo_id:14} {branch:24} {head:12} {dirty_text:>5} {upstream}")
+
+
+def cmd_agent_list(args: argparse.Namespace) -> None:
+    config = _config(args)
+    for adapter_id, adapter in sorted(config.adapters.items()):
+        print(f"{adapter_id:16} launch={shlex.join(adapter.launch)}")
+
+
+def cmd_open(args: argparse.Namespace) -> None:
+    config = _config(args)
+    line = get_line(config, args.line, args.kind)
+    try:
+        adapter = config.adapters[args.agent]
+    except KeyError as exc:
+        raise DyroError(f"未配置 Agent adapter：{args.agent}") from exc
+    workspace = line_root(config, line)
+    if not workspace.is_dir():
+        raise DyroError(f"开发线工作区不存在：{workspace}")
+    argv = expand_argv(adapter.launch, workspace=workspace, root=config.root, task="", line=line.id, prompt=args.prompt or "")
+    _print_command(argv)
+    if args.dry_run:
+        return
+    os.chdir(workspace)
+    os.execvp(argv[0], list(argv))
+
+
+def _choose(label: str, values: list[str]) -> str:
+    if not values:
+        raise DyroError(f"没有可选的 {label}")
+    if len(values) == 1:
+        return values[0]
+    print(f"请选择{label}：")
+    for index, value in enumerate(values, start=1):
+        print(f"  {index}) {value}")
+    raw = input("编号：").strip()
+    if not raw.isdigit() or not (1 <= int(raw) <= len(values)):
+        raise DyroError(f"无效的{label}选择")
+    return values[int(raw) - 1]
+
+
+def cmd_start(args: argparse.Namespace) -> None:
+    """Newcomer-friendly path: validate, select a line, then open an Agent."""
+    config = _config(args)
+    findings = doctor(config)
+    failures = [finding for finding in findings if finding.startswith("FAIL")]
+    if failures:
+        print("\n".join(failures))
+        raise DyroError("工作区尚未就绪；先修复 doctor 失败项，或运行 dyro bootstrap --yes")
+    line_id = args.line or _choose("开发线", [line.id for line in list_lines(config)])
+    line = get_line(config, line_id, args.kind)
+    agent = args.agent or _choose("Agent", sorted(config.adapters))
+    open_args = argparse.Namespace(root=str(config.root), line=line.id, kind=line.kind, agent=agent, prompt=args.prompt or "", dry_run=args.dry_run)
+    cmd_open(open_args)
+
+
+def cmd_line_list(args: argparse.Namespace) -> None:
+    config = _config(args)
+    lines = list_lines(config, args.kind)
+    if not lines:
+        print("暂无已登记开发线")
+        return
+    print(f"{'KIND':8} {'ID':28} {'BRANCH':30} {'BASE':24} REPOSITORIES")
+    for line in lines:
+        print(f"{line.kind:8} {line.id:28} {line.branch:30} {line.base:24} {', '.join(line.repositories)}")
+
+
+def _create_line(args: argparse.Namespace, kind: str) -> None:
+    config = _config(args)
+    _require_yes(args, "创建开发线")
+    branch = args.branch or (f"hotfix/{args.id}" if kind == "hotfix" else f"feat/{args.id}")
+    if kind == "hotfix" and not args.base:
+        raise DyroError("Hotfix 必须显式提供 --base（已核实的 release/tag/deployed SHA）")
+    base = args.base or config.policy.default_base
+    line = create_line(
+        config,
+        line_id=args.id,
+        branch=branch,
+        base=base,
+        repositories=_repositories(args.repos),
+        kind=kind,
+        dry_run=args.dry_run,
+    )
+    print(f"{'DRY RUN: ' if args.dry_run else ''}已创建 {line.kind} {line.id}，分支 {line.branch}，基线 {line.base}")
+
+
+def cmd_line_create(args: argparse.Namespace) -> None:
+    _create_line(args, "line")
+
+
+def cmd_hotfix_create(args: argparse.Namespace) -> None:
+    _create_line(args, "hotfix")
+
+
+def cmd_task_create(args: argparse.Namespace) -> None:
+    config = _config(args)
+    validate_id(args.id, "任务 ID")
+    get_line(config, args.line)
+    if args.repository not in config.repositories:
+        raise DyroError(f"未配置仓库：{args.repository}")
+    path = config.task_specs_dir / args.id
+    if path.exists():
+        raise DyroError(f"任务目录已存在：{path}")
+    if args.dry_run:
+        print(f"DRY RUN: 将创建 {path}")
+        return
+    path.mkdir(parents=True)
+    mount = config.repositories[args.repository].mount
+    (path / "task.toml").write_text(task_template(args.id, args.title, args.line, args.repository, mount), encoding="utf-8")
+    (path / "handoff.md").write_text(f"# {args.title}\n\n- 目标：\n- 范围：\n- 验收：\n", encoding="utf-8")
+    print(f"已创建任务：{path}")
+
+
+def cmd_task_list(args: argparse.Namespace) -> None:
+    config = _config(args)
+    for task in list_tasks(config):
+        print(f"{task.id:30} {task_status(config, task):16} {task.line:20} {task.title}")
+
+
+def cmd_task_board(args: argparse.Namespace) -> None:
+    print(board(_config(args)), end="")
+
+
+def cmd_task_status(args: argparse.Namespace) -> None:
+    config = _config(args)
+    task = load_task(config, args.id)
+    if args.value is None:
+        print(task_status(config, task))
+        return
+    set_status(config, task, args.value, force=args.force, dry_run=args.dry_run)
+    print(f"{'DRY RUN: ' if args.dry_run else ''}{task.id} -> {args.value}")
+
+
+def cmd_task_run(args: argparse.Namespace) -> None:
+    config = _config(args)
+    task = load_task(config, args.id)
+    result = run_task(config, task, dry_run=args.dry_run)
+    print(f"{task.id} -> {result}")
+
+
+def cmd_task_next(args: argparse.Namespace) -> None:
+    config = _config(args)
+    candidates = []
+    for task in list_tasks(config):
+        if task_status(config, task) not in ("backlog", "assigned"):
+            continue
+        try:
+            check_dispatchable(config, task)
+            candidates.append(task)
+        except DyroError:
+            continue
+    if args.id:
+        candidates = [task for task in candidates if task.id == args.id]
+    if not candidates:
+        raise DyroError("没有可执行任务；可检查 task board 与 decisions")
+    if not args.run:
+        for task in candidates:
+            print(f"{task.id:30} {task.line:20} {task.title}")
+        print("运行：dyro task next --run --yes" + (" --id <任务ID>" if len(candidates) > 1 else ""))
+        return
+    _require_yes(args, "启动下一个任务")
+    if len(candidates) > 1:
+        if not args.id:
+            selected_id = _choose("任务", [task.id for task in candidates])
+            candidates = [task for task in candidates if task.id == selected_id]
+    task = candidates[0]
+    print(f"{task.id} -> {run_task(config, task, dry_run=args.dry_run)}")
+
+
+def cmd_task_answer(args: argparse.Namespace) -> None:
+    config = _config(args)
+    task = load_task(config, args.id)
+    if args.file:
+        answer = Path(args.file).read_text(encoding="utf-8")
+    else:
+        answer = args.text
+    if not answer.strip():
+        raise DyroError("回答不能为空")
+    print(f"{task.id} -> {answer_task(config, task, answer, dry_run=args.dry_run)}")
+
+
+def cmd_task_gates(args: argparse.Namespace) -> None:
+    config = _config(args)
+    task = load_task(config, args.id)
+    passed = run_gates(config, task, dry_run=args.dry_run)
+    print("PASS" if passed else "FAIL")
+    if not passed:
+        raise DyroError(f"任务 {task.id} 门禁未通过")
+
+
+def cmd_task_review(args: argparse.Namespace) -> None:
+    config = _config(args)
+    task = load_task(config, args.id)
+    print(f"{task.id} -> {review_task(config, task, dry_run=args.dry_run)}")
+
+
+def cmd_task_merge(args: argparse.Namespace) -> None:
+    _require_yes(args, "合并任务")
+    config = _config(args)
+    task = load_task(config, args.id)
+    merge_task(config, task, push=args.push, dry_run=args.dry_run)
+    print(f"{'DRY RUN: ' if args.dry_run else ''}已合并 {task.id}" + (" 并推送" if args.push else ""))
+
+
+def cmd_task_decisions(args: argparse.Namespace) -> None:
+    items = decisions(_config(args))
+    if not items:
+        print("暂无决策点")
+        return
+    for key, value in sorted(items.items()):
+        print(f"{key:32} {value}")
+
+
+def cmd_task_stats(args: argparse.Namespace) -> None:
+    report = stats(_config(args))
+    if not report:
+        print("台账为空")
+        return
+    print(f"{'AGENT':18} {'EXEC':>5} {'EXEC OK':>8} {'REVIEW':>7} {'REVIEW OK':>10}")
+    for agent, counters in sorted(report.items()):
+        print(f"{agent:18} {counters['executor']:>5} {counters['executor_ok']:>8} {counters['review']:>7} {counters['review_ok']:>10}")
+
+
+def cmd_task_loop(args: argparse.Namespace) -> None:
+    for task_id, result in loop_tasks(_config(args), dry_run=args.dry_run):
+        print(f"{task_id} -> {result}")
+
+
+def cmd_task_daemon(args: argparse.Namespace) -> None:
+    config = _config(args)
+    while True:
+        tasks = list_tasks(config)
+        active_groups = {task.conflict_group for task in tasks if task.conflict_group and task_status(config, task) == "in_progress"}
+        queued = []
+        for task in tasks:
+            if task_status(config, task) != "assigned" or len(queued) >= max(1, args.parallel):
+                continue
+            if task.conflict_group and task.conflict_group in active_groups:
+                continue
+            queued.append(task)
+            if task.conflict_group:
+                active_groups.add(task.conflict_group)
+        if queued:
+            with ThreadPoolExecutor(max_workers=max(1, args.parallel), thread_name_prefix="dyro-dispatch") as pool:
+                futures = {pool.submit(run_task, config, task, dry_run=args.dry_run): task for task in queued}
+                for future in as_completed(futures):
+                    task = futures[future]
+                    try:
+                        print(f"dispatch {task.id} -> {future.result()}")
+                    except DyroError as exc:
+                        print(f"skip {task.id}: {exc}")
+        review_queue = [task for task in list_tasks(config) if task_status(config, task) == "review"]
+        if review_queue:
+            with ThreadPoolExecutor(max_workers=max(1, args.parallel), thread_name_prefix="dyro-review") as pool:
+                futures = {pool.submit(review_task, config, task, dry_run=args.dry_run): task for task in review_queue}
+                for future in as_completed(futures):
+                    task = futures[future]
+                    try:
+                        print(f"review {task.id} -> {future.result()}")
+                    except DyroError as exc:
+                        print(f"keep review {task.id}: {exc}")
+        if args.once or args.dry_run:
+            return
+        time.sleep(max(10, args.interval))
+
+
+def _add_common(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--root", help="工作区根目录；默认从当前目录向上查找 dyro.toml")
+    parser.add_argument("--dry-run", action="store_true", help="仅输出计划，不写文件、不调用 Agent 或 Git 写操作")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="dyro", description="DyroEngineeringFlow：本地优先的多仓工程自动化与交付控制平台")
+    parser.add_argument("--version", action="version", version=f"dyro {__version__}")
+    _add_common(parser)
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    init = sub.add_parser("init", help="初始化工作区配置")
+    init.add_argument("path", nargs="?", default=".")
+    init.add_argument("--name", default="my-workspace")
+    init.add_argument("--wizard", action="store_true", help="交互式登记真实仓库与可选 remote")
+    init.set_defaults(func=cmd_init)
+
+    sub.add_parser("doctor", help="验证动态工作区结构").set_defaults(func=cmd_doctor)
+    sub.add_parser("status", help="显示 anchors 与开发线 Git 状态").set_defaults(func=cmd_status)
+    bootstrap_parser = sub.add_parser("bootstrap", help="clone 配置了 remote 的缺失仓库 anchor")
+    bootstrap_parser.add_argument("--yes", action="store_true")
+    bootstrap_parser.set_defaults(func=cmd_bootstrap)
+    agent = sub.add_parser("agent", help="Agent adapters")
+    agent_sub = agent.add_subparsers(dest="agent_command", required=True)
+    agent_sub.add_parser("list").set_defaults(func=cmd_agent_list)
+    open_cmd = sub.add_parser("open", help="在指定开发线启动 Agent")
+    open_cmd.add_argument("line")
+    open_cmd.add_argument("--kind", choices=("line", "hotfix"))
+    open_cmd.add_argument("--agent", default="codex")
+    open_cmd.add_argument("--prompt", default="")
+    open_cmd.set_defaults(func=cmd_open)
+    start = sub.add_parser("start", help="新人入口：检查工作区、选择开发线和 Agent")
+    start.add_argument("--line")
+    start.add_argument("--kind", choices=("line", "hotfix"))
+    start.add_argument("--agent")
+    start.add_argument("--prompt", default="")
+    start.set_defaults(func=cmd_start)
+
+    line = sub.add_parser("line", help="功能开发线")
+    line_sub = line.add_subparsers(dest="line_command", required=True)
+    line_list = line_sub.add_parser("list")
+    line_list.add_argument("--kind", choices=("line", "hotfix"))
+    line_list.set_defaults(func=cmd_line_list)
+    line_create = line_sub.add_parser("create")
+    line_create.add_argument("id")
+    line_create.add_argument("--branch")
+    line_create.add_argument("--base")
+    line_create.add_argument("--repos", help="逗号分隔；默认全部 configured repositories")
+    line_create.add_argument("--yes", action="store_true")
+    line_create.set_defaults(func=cmd_line_create)
+
+    hotfix = sub.add_parser("hotfix", help="生产 Hotfix 开发线")
+    hotfix_sub = hotfix.add_subparsers(dest="hotfix_command", required=True)
+    hotfix_create = hotfix_sub.add_parser("create")
+    hotfix_create.add_argument("id")
+    hotfix_create.add_argument("--branch")
+    hotfix_create.add_argument("--base", required=True)
+    hotfix_create.add_argument("--repos")
+    hotfix_create.add_argument("--yes", action="store_true")
+    hotfix_create.set_defaults(func=cmd_hotfix_create)
+
+    task = sub.add_parser("task", help="任务编排")
+    task_sub = task.add_subparsers(dest="task_command", required=True)
+    task_create = task_sub.add_parser("create")
+    task_create.add_argument("id")
+    task_create.add_argument("--title", required=True)
+    task_create.add_argument("--line", required=True)
+    task_create.add_argument("--repository", required=True)
+    task_create.set_defaults(func=cmd_task_create)
+    task_sub.add_parser("list").set_defaults(func=cmd_task_list)
+    task_sub.add_parser("board").set_defaults(func=cmd_task_board)
+    task_status_parser = task_sub.add_parser("status")
+    task_status_parser.add_argument("id")
+    task_status_parser.add_argument("value", nargs="?", choices=STATUSES)
+    task_status_parser.add_argument("--force", action="store_true")
+    task_status_parser.set_defaults(func=cmd_task_status)
+    task_run = task_sub.add_parser("run")
+    task_run.add_argument("id")
+    task_run.set_defaults(func=cmd_task_run)
+    task_next = task_sub.add_parser("next", help="显示或启动下一个满足依赖的任务")
+    task_next.add_argument("--id")
+    task_next.add_argument("--run", action="store_true")
+    task_next.add_argument("--yes", action="store_true")
+    task_next.set_defaults(func=cmd_task_next)
+    task_answer = task_sub.add_parser("answer")
+    task_answer.add_argument("id")
+    group = task_answer.add_mutually_exclusive_group(required=True)
+    group.add_argument("--text")
+    group.add_argument("--file")
+    task_answer.set_defaults(func=cmd_task_answer)
+    task_gates = task_sub.add_parser("gates")
+    task_gates.add_argument("id")
+    task_gates.set_defaults(func=cmd_task_gates)
+    task_review = task_sub.add_parser("review")
+    task_review.add_argument("id")
+    task_review.set_defaults(func=cmd_task_review)
+    task_merge = task_sub.add_parser("merge")
+    task_merge.add_argument("id")
+    task_merge.add_argument("--yes", action="store_true")
+    task_merge.add_argument("--push", action="store_true")
+    task_merge.set_defaults(func=cmd_task_merge)
+    task_sub.add_parser("decisions").set_defaults(func=cmd_task_decisions)
+    task_sub.add_parser("stats").set_defaults(func=cmd_task_stats)
+    task_sub.add_parser("loop").set_defaults(func=cmd_task_loop)
+    daemon = task_sub.add_parser("daemon")
+    daemon.add_argument("--parallel", type=int, default=2)
+    daemon.add_argument("--interval", type=int, default=30)
+    daemon.add_argument("--once", action="store_true")
+    daemon.set_defaults(func=cmd_task_daemon)
+    return parser
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    try:
+        args.func(args)
+    except DyroError as exc:
+        parser.exit(2, f"错误：{exc}\n")
+
+
+if __name__ == "__main__":
+    main()