@michaelxwb/code-flow 0.6.5 → 0.8.1

package/src/core/code-flow/scripts/codeflow/cli/cf_sync.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+"""cf-sync: one-command canonical → deploy sync for dual-copy artifacts.
+
+Pairs (canonical source → deployed live copy), each with an explicit include
+prefix list. Project-owned trees (specs/, tasks/) and merge-managed files
+(CLAUDE.md, AGENTS.md, settings.local.json, hooks.json, config.toml,
+opencode.json, config.yml, validation.yml) are upgraded by `code-flow init`
+with additive merges, not by byte-sync:
+
+  src/core/code-flow         → .code-flow        (scripts/, runtime-commands.json, .version, .gitignore)
+  src/adapters/claude        → .claude           (commands/)
+  src/adapters/codex/skills  → .agents/skills    (everything)
+  src/adapters/costrict      → .costrict         (commands/)
+  src/adapters/opencode      → .opencode         (commands/, plugins/)
+
+`check` (default) reports drift; `sync` copies canonical → deploy. Deploy-only
+files are never deleted (use --prune to remove files whose source side no
+longer contains them within the include prefixes).
+"""
+
+import argparse
+import json
+import os
+from pathlib import Path
+import sys
+from typing import IO, Optional, Sequence
+
+
+PAIRS = (
+    ("src/core/code-flow", ".code-flow", ("scripts/", "runtime-commands.json", ".version", ".gitignore")),
+    ("src/adapters/claude", ".claude", ("commands/",)),
+    ("src/adapters/codex/skills", ".agents/skills", ("*",)),
+    ("src/adapters/costrict", ".costrict", ("commands/",)),
+    ("src/adapters/opencode", ".opencode", ("commands/", "plugins/")),
+)
+
+_IGNORED_DIRS = {"__pycache__", ".git", "node_modules", "dist", "build"}
+
+
+def _included(relative: str, prefixes: Sequence[str]) -> bool:
+    return any(prefix == "*" or relative.startswith(prefix) for prefix in prefixes)
+
+
+def _walk(source: Path) -> list[str]:
+    files = []
+    for current, dirs, names in os.walk(source):
+        dirs[:] = sorted(item for item in dirs if item not in _IGNORED_DIRS)
+        base = Path(current)
+        for name in names:
+            files.append(str((base / name).relative_to(source)))
+    return sorted(files)
+
+
+def _relative(relative: str) -> str:
+    return relative.replace("\\", "/")
+
+
+def _canonical_bytes(root: Path, source: Path) -> bytes:
+    if source == root / "src/adapters/opencode/plugins/code-flow/package.json":
+        data = json.loads(source.read_text(encoding="utf-8"))
+        data["version"] = json.loads((root / "package.json").read_text(encoding="utf-8"))["version"]
+        return (json.dumps(data, indent=2, ensure_ascii=False) + "\n").encode("utf-8")
+    return source.read_bytes()
+
+
+def _pair_diffs(root: Path, source_rel: str, deploy_rel: str, prefixes: Sequence[str]) -> tuple[list[str], list[str], list[str]]:
+    """Return (differ, missing_in_deploy, deploy_only_within_prefixes)."""
+    source = root / source_rel
+    deploy = root / deploy_rel
+    differ: list[str] = []
+    missing: list[str] = []
+    for relative in _walk(source):
+        if not _included(_relative(relative), prefixes):
+            continue
+        source_file = source / relative
+        deploy_file = deploy / relative
+        if not deploy_file.exists():
+            missing.append(relative)
+        elif _canonical_bytes(root, source_file) != deploy_file.read_bytes():
+            differ.append(relative)
+    deploy_only: list[str] = []
+    if deploy.is_dir():
+        deploy_relative = set(_walk(deploy))
+        source_relative = {_relative(item) for item in _walk(source) if _included(_relative(item), prefixes)}
+        deploy_only = sorted(item for item in deploy_relative if item not in source_relative and _included(item, prefixes))
+    return differ, missing, deploy_only
+
+
+def _report(stdout: IO[str], root: Path, verbose: bool) -> int:
+    drift = 0
+    for source_rel, deploy_rel, prefixes in PAIRS:
+        differ, missing, deploy_only = _pair_diffs(root, source_rel, deploy_rel, prefixes)
+        status = "OK " if not (differ or missing) else "DRIFT"
+        stdout.write(f"{status} {source_rel} -> {deploy_rel}\n")
+        for relative in differ:
+            stdout.write(f"  diff  {deploy_rel}/{relative}\n")
+            drift += 1
+        for relative in missing:
+            stdout.write(f"  miss  {deploy_rel}/{relative}\n")
+            drift += 1
+        if verbose and deploy_only:
+            stdout.write(f"  only-in-deploy ({len(deploy_only)}):\n")
+            for relative in deploy_only[:10]:
+                stdout.write(f"    {deploy_rel}/{relative}\n")
+    return drift
+
+
+def _sync(root: Path, stdout: IO[str]) -> int:
+    copied = 0
+    for source_rel, deploy_rel, prefixes in PAIRS:
+        source = root / source_rel
+        deploy = root / deploy_rel
+        for relative in _walk(source):
+            if not _included(_relative(relative), prefixes):
+                continue
+            source_file = source / relative
+            deploy_file = deploy / relative
+            content = _canonical_bytes(root, source_file)
+            if deploy_file.exists() and content == deploy_file.read_bytes():
+                continue
+            deploy_file.parent.mkdir(parents=True, exist_ok=True)
+            deploy_file.write_bytes(content)
+            stdout.write(f"sync  {deploy_rel}/{relative}\n")
+            copied += 1
+    return copied
+
+
+def main(argv: Optional[Sequence[str]] = None, stdout: IO[str] = sys.stdout) -> int:
+    parser = argparse.ArgumentParser(prog=os.environ.get("CF_RUNTIME_COMMAND", "cf_sync.py"))
+    parser.add_argument("action", choices=("check", "sync"), nargs="?", default="check")
+    parser.add_argument("--root", default=".")
+    parser.add_argument("--verbose", action="store_true")
+    args = parser.parse_args(argv)
+    root = Path(args.root).resolve()
+    if args.action == "check":
+        drift = _report(stdout, root, args.verbose)
+        if drift:
+            stdout.write(f"{drift} file(s) drifted; run `code-flow sync apply` to deploy.\n")
+            return 1
+        stdout.write("all pairs in sync.\n")
+        return 0
+    copied = _sync(root, stdout)
+    stdout.write(f"{copied} file(s) deployed.\n")
+    return 0

package/src/core/code-flow/scripts/codeflow/cli/cf_task_index.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+"""Programmatic task-file index: parse TASK statuses/depends, compute DAG batches.
+
+Single worktrees allow one active TASK at a time; batches list *independently
+developable* tasks (no dependency path between them). `cf-task:start` may
+dispatch batch tasks in their own worktrees for parallel subagents — the
+single-active constraint stays per worktree.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import json
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import IO, Mapping, Optional, Sequence
+
+
+from codeflow.task.cf_task_doc import TaskDocument, TaskDocumentError, parse_task_document
+from codeflow.task.cf_task_plan import (
+    DEFAULT_MAX_TASKS,
+    TASK_SIZES,
+    evaluate_plan,
+)
+from codeflow.core.cf_task_state import FINISHED_STATUSES as _DONE_STATUSES
+
+
+@dataclass(frozen=True)
+class TaskNode:
+    task_id: str
+    status: str
+    depends: tuple[str, ...]
+
+
+def project_task_nodes(document: TaskDocument) -> tuple[TaskNode, ...]:
+    """Project a parsed TaskDocument into the index node shape."""
+    return tuple(TaskNode(task.id, task.status, task.depends) for task in document.tasks)
+
+
+def parse_task_file(task_file: str) -> tuple[TaskNode, ...]:
+    """Parse every `## TASK-xxx` section into status/depends nodes.
+
+    Unknown statuses are preserved verbatim (e.g. `verified` from the E2E
+    flow) — the parser never rejects them, completion checks treat done and
+    verified as finished.
+    """
+    try:
+        text = Path(task_file).read_text(encoding="utf-8")
+    except (OSError, UnicodeError) as exc:
+        raise ValueError(f"task_read_error: {exc}") from exc
+    try:
+        document = parse_task_document(text, source=str(task_file))
+    except TaskDocumentError as exc:
+        raise ValueError(str(exc)) from exc
+    return project_task_nodes(document)
+
+
+def task_batches(nodes: Sequence[TaskNode]) -> list[list[str]]:
+    """Topological batches over unfinished TASKs; unknown deps and cycles raise."""
+    ids = {node.task_id for node in nodes}
+    for node in nodes:
+        unknown = [dep for dep in node.depends if dep not in ids]
+        if unknown:
+            raise ValueError(f"unknown depends: {node.task_id} -> {', '.join(unknown)}")
+    pending = {node.task_id for node in nodes if node.status not in _DONE_STATUSES}
+    finished = {node.task_id for node in nodes if node.status in _DONE_STATUSES}
+    deps = {node.task_id: set(node.depends) for node in nodes}
+    batches: list[list[str]] = []
+    while pending:
+        ready = sorted(task for task in pending if deps[task] <= finished)
+        if not ready:
+            raise ValueError(f"dependency cycle among: {', '.join(sorted(pending))}")
+        batches.append(ready)
+        finished.update(ready)
+        pending.difference_update(ready)
+    return batches
+
+
+def dependency_components(nodes: Sequence[TaskNode]) -> list[list[str]]:
+    """Connected dependency components; different components are independent."""
+    parent = {node.task_id: node.task_id for node in nodes}
+
+    def find(task: str) -> str:
+        while parent[task] != task:
+            parent[task] = parent[parent[task]]
+            task = parent[task]
+        return task
+
+    for node in nodes:
+        for dep in node.depends:
+            left, right = find(node.task_id), find(dep)
+            if left != right:
+                parent[left] = right
+    groups: dict[str, list[str]] = {}
+    for node in nodes:
+        groups.setdefault(find(node.task_id), []).append(node.task_id)
+    return [sorted(members) for members in groups.values()]
+
+
+def independent_groups(nodes: Sequence[TaskNode]) -> list[list[str]]:
+    """Compatibility alias: groups are independent of each other, not within."""
+    return dependency_components(nodes)
+
+
+def index_data(
+    task_file: str,
+    *,
+    budget: bool = False,
+    task_size: str = "capability",
+    max_tasks: int = DEFAULT_MAX_TASKS,
+    min_average_hours: Optional[float] = None,
+) -> dict[str, object]:
+    nodes = parse_task_file(task_file)
+    data: dict[str, object] = {
+        "tasks": [
+            {"id": node.task_id, "status": node.status, "depends": list(node.depends)}
+            for node in nodes
+        ],
+        "batches": task_batches(nodes),
+        "independent_groups": independent_groups(nodes),
+        "dependency_components": dependency_components(nodes),
+        "note": "batches 组内无依赖；dependency_components 仅组间独立（independent_groups 为兼容别名）；单 worktree 一次仅激活一个 TASK，批次内独立任务可由 cf-task:start 在各 worktree 并行派发",
+    }
+    if budget:
+        data["budget"] = evaluate_plan(
+            task_file,
+            task_size=task_size,
+            max_tasks=max_tasks,
+            min_average_hours=min_average_hours,
+        )
+    return data
+
+
+def main(argv: Optional[Sequence[str]] = None, stdout: IO[str] = sys.stdout) -> int:
+    parser = argparse.ArgumentParser(prog=os.environ.get("CF_RUNTIME_COMMAND", "cf_task_index.py"))
+    parser.add_argument("--task-file", required=True)
+    parser.add_argument("--dag", action="store_true", help="输出拓扑批次与独立分组")
+    parser.add_argument("--budget", action="store_true", help="附加能力级计划预算评估")
+    parser.add_argument("--task-size", choices=TASK_SIZES, default="capability")
+    parser.add_argument("--max-tasks", type=int, default=DEFAULT_MAX_TASKS)
+    parser.add_argument("--min-average-hours", type=float, default=None)
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args(argv)
+    try:
+        data = index_data(
+            args.task_file,
+            budget=args.budget,
+            task_size=args.task_size,
+            max_tasks=args.max_tasks,
+            min_average_hours=args.min_average_hours,
+        )
+    except (OSError, ValueError) as exc:
+        stdout.write(json.dumps({"ok": False, "error": str(exc)}, ensure_ascii=False))
+        return 2
+    if args.json or args.dag:
+        stdout.write(json.dumps(data, ensure_ascii=False))
+    else:
+        lines = ["TASK 索引:"]
+        for item in data["tasks"]:
+            lines.append(f"  - {item['id']}: {item['status']} (依赖: {', '.join(item['depends']) or '无'})")
+        for index, batch in enumerate(data["batches"], 1):
+            lines.append(f"批次 {index}（可独立开发）: {', '.join(batch)}")
+        if args.budget:
+            budget_data = data["budget"]
+            lines.append(
+                f"计划预算: {budget_data['task_count']} 任务 / 总计 {budget_data['total_hours']}h"
+                f" / 平均 {budget_data['average_hours']}h（{budget_data['task_size']}）"
+            )
+            for warning in budget_data["warnings"]:
+                lines.append(f"  ! {warning['message']}")
+            lines.append(f"decision: {budget_data['decision']}")
+        stdout.write("\n".join(lines) + "\n")
+    if args.budget and data["budget"]["requires_merge"]:
+        return 1
+    return 0