@michaelxwb/code-flow 0.8.1 → 1.0.0

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

@@ -1,144 +0,0 @@
-#!/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

@@ -1,177 +0,0 @@
-#!/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