cowork-flow 0.0.3 → 0.0.5

package/template/.cowork-flow/scripts/common/agent_team.py

@@ -0,0 +1,241 @@
+"""Helpers for the cowork-flow agent team runtime."""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+
+
+TASK_RE = re.compile(r"^### Task\s+(\d+):\s*(.+?)\s*$")
+FILE_RE = re.compile(r"^-\s+(Create|Modify|Test):\s+`([^`]+)`")
+DEP_RE = re.compile(r"depends on Task\s+(\d+)", re.IGNORECASE)
+
+
+def parse_plan(text: str) -> list[dict[str, object]]:
+    tasks: list[dict[str, object]] = []
+    current: dict[str, object] | None = None
+
+    for raw_line in text.splitlines():
+        line = raw_line.rstrip()
+        task_match = TASK_RE.match(line)
+        if task_match:
+            current = {
+                "number": int(task_match.group(1)),
+                "id": f"T{int(task_match.group(1)):03d}",
+                "title": task_match.group(2),
+                "files": [],
+                "steps": [],
+                "commands": [],
+                "explicit_dependencies": [],
+            }
+            tasks.append(current)
+            continue
+
+        if current is None:
+            continue
+
+        file_match = FILE_RE.match(line.strip())
+        if file_match:
+            current["files"].append(
+                {
+                    "kind": file_match.group(1).lower(),
+                    "path": file_match.group(2),
+                }
+            )
+            continue
+
+        stripped = line.strip()
+        if stripped.startswith("- [ ]"):
+            current["steps"].append(stripped)
+            continue
+
+        if stripped.startswith("Run:"):
+            current["commands"].append(stripped.removeprefix("Run:").strip())
+
+        dep_match = DEP_RE.search(stripped)
+        if dep_match:
+            current["explicit_dependencies"].append(f"T{int(dep_match.group(1)):03d}")
+
+    return tasks
+
+
+def _task_files(task: dict[str, object]) -> set[str]:
+    files = task.get("files", [])
+    if not isinstance(files, list):
+        return set()
+    paths = set()
+    for item in files:
+        if isinstance(item, dict) and isinstance(item.get("path"), str):
+            paths.add(item["path"])
+    return paths
+
+
+def _task_dependencies(tasks: list[dict[str, object]]) -> list[dict[str, str]]:
+    dependencies: list[dict[str, str]] = []
+    for index, task in enumerate(tasks):
+        task_id = str(task["id"])
+        task_files = _task_files(task)
+
+        explicit = task.get("explicit_dependencies", [])
+        if isinstance(explicit, list):
+            for dependency in explicit:
+                dependencies.append(
+                    {
+                        "task": task_id,
+                        "depends_on_task": str(dependency),
+                        "reason": "explicit",
+                    }
+                )
+
+        for previous in tasks[:index]:
+            previous_files = _task_files(previous)
+            if task_files.intersection(previous_files):
+                dependencies.append(
+                    {
+                        "task": task_id,
+                        "depends_on_task": str(previous["id"]),
+                        "reason": "file-overlap",
+                    }
+                )
+
+    return dependencies
+
+
+def _role_agent(role: str) -> tuple[str, str]:
+    if role == "implementer":
+        return ("implementer", "worker")
+    if role == "spec-reviewer":
+        return ("spec-reviewer", "default")
+    return ("quality-reviewer", "default")
+
+
+def build_dispatch_plan(tasks: list[dict[str, object]]) -> dict[str, object]:
+    assignments: list[dict[str, object]] = []
+    task_dependencies = _task_dependencies(tasks)
+    dependency_lookup: dict[str, list[str]] = {}
+    for dependency in task_dependencies:
+        dependency_lookup.setdefault(dependency["task"], []).append(dependency["depends_on_task"])
+
+    for task in tasks:
+        task_id = str(task["id"])
+        task_dependency_assignments = [
+            f"{dependency}-quality-reviewer"
+            for dependency in dependency_lookup.get(task_id, [])
+        ]
+        chain = [
+            ("implementer", task_dependency_assignments),
+            ("spec-reviewer", [f"{task_id}-implementer"]),
+            ("quality-reviewer", [f"{task_id}-spec-reviewer"]),
+        ]
+        for role, depends_on in chain:
+            agent, codex_type = _role_agent(role)
+            assignments.append(
+                {
+                    "id": f"{task_id}-{role}",
+                    "task": task_id,
+                    "title": task["title"],
+                    "role": role,
+                    "recommended_agent": agent,
+                    "codex_type": codex_type,
+                    "depends_on": depends_on,
+                    "files": task.get("files", []),
+                    "steps": task.get("steps", []),
+                    "commands": task.get("commands", []),
+                }
+            )
+
+    return {
+        "version": 1,
+        "adapter": "codex",
+        "tasks": tasks,
+        "task_dependencies": task_dependencies,
+        "assignments": assignments,
+    }
+
+
+def render_dispatch_plan(dispatch_plan: dict[str, object]) -> str:
+    lines = [
+        "version: 1",
+        f"adapter: {dispatch_plan['adapter']}",
+        "task_dependencies:",
+    ]
+    for dependency in dispatch_plan["task_dependencies"]:
+        lines.extend(
+            [
+                f"  - task: {dependency['task']}",
+                f"    depends_on_task: {dependency['depends_on_task']}",
+                f"    reason: {dependency['reason']}",
+            ]
+        )
+    lines.append("assignments:")
+    for assignment in dispatch_plan["assignments"]:
+        lines.extend(
+            [
+                f"  - id: {assignment['id']}",
+                f"    task: {assignment['task']}",
+                f"    role: {assignment['role']}",
+                f"    recommended_agent: {assignment['recommended_agent']}",
+                f"    codex_type: {assignment['codex_type']}",
+                "    depends_on:",
+            ]
+        )
+        depends_on = assignment.get("depends_on", [])
+        if depends_on:
+            for dependency in depends_on:
+                lines.append(f"      - {dependency}")
+        else:
+            lines.append("      - none")
+    lines.append("")
+    return "\n".join(lines)
+
+
+def write_json(path: Path, data: dict[str, object]) -> None:
+    path.write_text(json.dumps(data, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+
+
+def build_initial_status(dispatch_plan: dict[str, object]) -> dict[str, object]:
+    assignments: dict[str, dict[str, object]] = {}
+    for assignment in dispatch_plan["assignments"]:
+        depends_on = [
+            dependency
+            for dependency in assignment.get("depends_on", [])
+            if dependency != "none"
+        ]
+        assignments[assignment["id"]] = {
+            "status": "ready" if not depends_on else "pending",
+            "attempts": 0,
+            "depends_on": depends_on,
+            "role": assignment["role"],
+            "task": assignment["task"],
+            "recommended_agent": assignment["recommended_agent"],
+            "codex_type": assignment["codex_type"],
+        }
+
+    return {"version": 1, "current_batch": 1, "assignments": assignments}
+
+
+def build_initial_metrics(dispatch_plan: dict[str, object]) -> dict[str, object]:
+    return {
+        "assignments": len(dispatch_plan["assignments"]),
+        "attempts": 0,
+        "successfulAssignments": 0,
+        "failedAssignments": 0,
+        "reviewReworks": 0,
+        "agents": {},
+    }
+
+
+def render_assignment_prompt(assignment: dict[str, object]) -> str:
+    return "\n".join(
+        [
+            f"# {assignment['id']}",
+            "",
+            f"Role: {assignment['role']}",
+            f"Recommended agent: {assignment['recommended_agent']}",
+            f"Codex type: {assignment['codex_type']}",
+            "",
+            "You are not alone in this codebase. Respect the write boundary, do not revert other agents' edits, and report changed files.",
+            "",
+        ]
+    )

package/template/.cowork-flow/scripts/common/config.py

@@ -15,6 +15,7 @@ from .paths import DIR_WORKFLOW, get_repo_root
 # Defaults
 DEFAULT_SESSION_COMMIT_MESSAGE = "chore: record journal"
 DEFAULT_MAX_JOURNAL_LINES = 2000
+DEFAULT_AGENT_TEAM_ENABLED = False
 
 CONFIG_FILE = "config.yaml"
 
@@ -108,6 +109,23 @@ def get_max_journal_lines(repo_root: Path | None = None) -> int:
         return DEFAULT_MAX_JOURNAL_LINES
 
 
+def _is_true(value: object) -> bool:
+    if value is True:
+        return True
+    if isinstance(value, str):
+        return value.strip().lower() == "true"
+    return False
+
+
+def get_agent_team_enabled(repo_root: Path | None = None) -> bool:
+    """Return whether agent-team runtime commands are enabled."""
+    config = _load_config(repo_root)
+    agent_team = config.get("agent_team")
+    if not isinstance(agent_team, dict):
+        return DEFAULT_AGENT_TEAM_ENABLED
+    return _is_true(agent_team.get("enabled"))
+
+
 def get_hooks(event: str, repo_root: Path | None = None) -> list[str]:
     """Get hook commands for a lifecycle event.
 

package/template/.cowork-flow/scripts/common/developer.py

@@ -174,7 +174,7 @@ def ensure_developer(repo_root: Path | None = None) -> None:
 
     if not check_developer(repo_root):
         print("Error: developer identity has not been initialized.", file=sys.stderr)
-        print(f"Run: python3 ./{DIR_WORKFLOW}/scripts/init_developer.py <your-name>", file=sys.stderr)
+        print(f"Run: ./{DIR_WORKFLOW}/run init-developer <your-name>", file=sys.stderr)
         sys.exit(1)
 
 

package/template/.cowork-flow/scripts/common/git_context.py

@@ -253,12 +253,19 @@ def _task_plan_references(repo_root: Path, snapshot: CurrentTaskSnapshot) -> lis
     return plan_refs
 
 
+def _task_has_agent_team_status(repo_root: Path, snapshot: CurrentTaskSnapshot) -> bool:
+    """Return whether the current task has persisted agent-team runtime state."""
+    if not snapshot.path:
+        return False
+    return (repo_root / snapshot.path / "agent-team" / "status.json").is_file()
+
+
 def _build_resume_checklist(
     repo_root: Path,
     snapshot: CurrentTaskSnapshot,
 ) -> dict[str, list[str]]:
     """构建最小恢复清单，只返回路径和命令，不展开文件内容。"""
-    commands = [f"python3 ./{DIR_WORKFLOW}/{DIR_SCRIPTS}/resume.py"]
+    commands = [f"./{DIR_WORKFLOW}/run resume"]
     read_files: list[str] = []
     notes: list[str] = []
 
@@ -268,7 +275,10 @@ def _build_resume_checklist(
         return {"commands": commands, "readFiles": read_files, "notes": notes}
 
     current_task = snapshot.path
-    commands.append(f"python3 ./{DIR_WORKFLOW}/{DIR_SCRIPTS}/task.py list-context {current_task}")
+    commands.append(f"./{DIR_WORKFLOW}/run task list-context {current_task}")
+    if _task_has_agent_team_status(repo_root, snapshot):
+        commands.append(f"./{DIR_WORKFLOW}/run agent-team status {current_task}")
+        commands.append(f"./{DIR_WORKFLOW}/run agent-team next {current_task}")
 
     if snapshot.has_prd:
         read_files.append(f"{current_task}/prd.md")
@@ -329,6 +339,13 @@ def _append_resume_checklist(
     else:
         lines.append("- No plan reference found in task context; do not search all plans unless needed.")
 
+    agent_team_commands = [
+        command for command in commands if f"./{DIR_WORKFLOW}/run agent-team " in command
+    ]
+    if agent_team_commands:
+        lines.append(f"- Check agent-team status: {agent_team_commands[0]}")
+        lines.append(f"- Continue agent-team dispatch: {agent_team_commands[1]}")
+
     lines.append("- Do not bulk-read .cowork-flow/spec/ or workspace journals; follow JSONL references on demand.")
     lines.append("")
 
@@ -503,7 +520,7 @@ def get_context_text(repo_root: Path | None = None) -> str:
     lines.append("## DEVELOPER")
     if not developer:
         lines.append(
-            f"ERROR: Not initialized. Run: python3 ./{DIR_WORKFLOW}/{DIR_SCRIPTS}/init_developer.py <name>"
+            f"ERROR: Not initialized. Run: ./{DIR_WORKFLOW}/run init-developer <name>"
         )
         return "\n".join(lines)
 
@@ -670,7 +687,7 @@ def get_context_text_record(repo_root: Path | None = None) -> str:
     developer = get_developer(repo_root)
     if not developer:
         lines.append(
-            f"ERROR: Not initialized. Run: python3 ./{DIR_WORKFLOW}/{DIR_SCRIPTS}/init_developer.py <name>"
+            f"ERROR: Not initialized. Run: ./{DIR_WORKFLOW}/run init-developer <name>"
         )
         return "\n".join(lines)
 

package/template/.cowork-flow/scripts/get_context.py

@@ -3,8 +3,8 @@
 Get Session Context for AI Agent.
 
 Usage:
-    python3 get_context.py           Output context in text format
-    python3 get_context.py --json    Output context in JSON format
+    ./.cowork-flow/run get-context           Output context in text format
+    ./.cowork-flow/run get-context --json    Output context in JSON format
 """
 
 from __future__ import annotations

package/template/.cowork-flow/scripts/init_developer.py

@@ -3,7 +3,7 @@
 Initialize developer for workflow.
 
 Usage:
-    python3 init_developer.py <developer-name>
+    ./.cowork-flow/run init-developer <developer-name>
 
 This creates:
     - .cowork-flow/.developer file with developer info

package/template/.cowork-flow/scripts/task.py

@@ -4,18 +4,18 @@
 Task Management Script for cowork-flow workflow.
 
 Usage:
-    python3 task.py create "<title>" [--slug <name>] [--assignee <dev>] [--priority P0|P1|P2|P3] [--parent <dir>]
-    python3 task.py init-context <dir> <type>   # Initialize jsonl files
-    python3 task.py add-context <dir> <file> <path> [reason] # Add jsonl entry
-    python3 task.py validate <dir>              # Validate jsonl files
-    python3 task.py list-context <dir>          # List jsonl entries
-    python3 task.py start <dir>                 # Set as current task
-    python3 task.py finish                      # Clear current task
-    python3 task.py archive <task-name>         # Archive completed task
-    python3 task.py list                        # List active tasks
-    python3 task.py list-archive [month]        # List archived tasks
-    python3 task.py add-subtask <parent-dir> <child-dir>     # Link child to parent
-    python3 task.py remove-subtask <parent-dir> <child-dir>  # Unlink child from parent
+    ./.cowork-flow/run task create "<title>" [--slug <name>] [--assignee <dev>] [--priority P0|P1|P2|P3] [--parent <dir>]
+    ./.cowork-flow/run task init-context <dir> <type>   # Initialize jsonl files
+    ./.cowork-flow/run task add-context <dir> <file> <path> [reason] # Add jsonl entry
+    ./.cowork-flow/run task validate <dir>              # Validate jsonl files
+    ./.cowork-flow/run task list-context <dir>          # List jsonl entries
+    ./.cowork-flow/run task start <dir>                 # Set as current task
+    ./.cowork-flow/run task finish                      # Clear current task
+    ./.cowork-flow/run task archive <task-name>         # Archive completed task
+    ./.cowork-flow/run task list                        # List active tasks
+    ./.cowork-flow/run task list-archive [month]        # List archived tasks
+    ./.cowork-flow/run task add-subtask <parent-dir> <child-dir>     # Link child to parent
+    ./.cowork-flow/run task remove-subtask <parent-dir> <child-dir>  # Unlink child from parent
 """
 
 from __future__ import annotations
@@ -630,8 +630,8 @@ def cmd_create(args: argparse.Namespace) -> int:
     print("", file=sys.stderr)
     print(colored("Next steps:", Colors.BLUE), file=sys.stderr)
     print("  1. Create prd.md with requirements", file=sys.stderr)
-    print("  2. Run: python3 task.py init-context <dir> <dev_type>", file=sys.stderr)
-    print("  3. Run: python3 task.py start <dir>", file=sys.stderr)
+    print("  2. Run: ./.cowork-flow/run task init-context <dir> <dev_type>", file=sys.stderr)
+    print("  3. Run: ./.cowork-flow/run task start <dir>", file=sys.stderr)
     print("", file=sys.stderr)
 
     # Output relative path for script chaining
@@ -653,7 +653,7 @@ def cmd_init_context(args: argparse.Namespace) -> int:
 
     if not dev_type:
         print(colored("Error: Missing arguments", Colors.RED))
-        print("Usage: python3 task.py init-context <task-dir> <dev_type>")
+        print("Usage: ./.cowork-flow/run task init-context <task-dir> <dev_type>")
         print("  dev_type: backend | frontend | fullstack | test | docs")
         return 1
 
@@ -699,8 +699,8 @@ def cmd_init_context(args: argparse.Namespace) -> int:
     print(colored("[OK] All context files created", Colors.GREEN))
     print()
     print(colored("Next steps:", Colors.BLUE))
-    print("  1. Add task-specific specs: python3 task.py add-context <dir> <jsonl> <path>")
-    print("  2. Set as current: python3 task.py start <dir>")
+    print("  1. Add task-specific specs: ./.cowork-flow/run task add-context <dir> <jsonl> <path>")
+    print("  2. Set as current: ./.cowork-flow/run task start <dir>")
 
     return 0
 
@@ -914,7 +914,7 @@ def cmd_start(args: argparse.Namespace) -> int:
         for blocker in blockers:
             print(f"  - {blocker}", file=sys.stderr)
         print(
-            "Hint: write prd.md, run python3 ./.cowork-flow/scripts/task.py init-context <dir> <dev_type>, then retry",
+            "Hint: write prd.md, run ./.cowork-flow/run task init-context <dir> <dev_type>, then retry",
             file=sys.stderr,
         )
         return 1
@@ -925,14 +925,14 @@ def cmd_start(args: argparse.Namespace) -> int:
         for issue in validation_issues:
             print(f"  - {issue}", file=sys.stderr)
         print(
-            "Hint: run python3 ./.cowork-flow/scripts/task.py validate <dir> and fix the reported issues",
+            "Hint: run ./.cowork-flow/run task validate <dir> and fix the reported issues",
             file=sys.stderr,
         )
         return 1
 
     # Convert to relative path for storage
     try:
-        task_dir = str(full_path.relative_to(repo_root))
+        task_dir = full_path.relative_to(repo_root).as_posix()
     except ValueError:
         task_dir = str(full_path)
 
@@ -1311,19 +1311,19 @@ def show_usage() -> None:
     print("""Task Management Script for cowork-flow workflow
 
 Usage:
-  python3 task.py create <title>                     Create new task directory
-  python3 task.py create <title> --parent <dir>      Create task as child of parent
-  python3 task.py init-context <dir> <dev_type>      Initialize jsonl files
-  python3 task.py add-context <dir> <jsonl> <path> [reason]  Add entry to jsonl
-  python3 task.py validate <dir>                     Validate jsonl files
-  python3 task.py list-context <dir>                 List jsonl entries
-  python3 task.py start <dir>                        Set as current task
-  python3 task.py finish                             Clear current task
-  python3 task.py archive <task-name>                Archive completed task
-  python3 task.py add-subtask <parent> <child>       Link child task to parent
-  python3 task.py remove-subtask <parent> <child>    Unlink child from parent
-  python3 task.py list [--mine] [--status <status>]  List tasks
-  python3 task.py list-archive [YYYY-MM]             List archived tasks
+  ./.cowork-flow/run task create <title>                     Create new task directory
+  ./.cowork-flow/run task create <title> --parent <dir>      Create task as child of parent
+  ./.cowork-flow/run task init-context <dir> <dev_type>      Initialize jsonl files
+  ./.cowork-flow/run task add-context <dir> <jsonl> <path> [reason]  Add entry to jsonl
+  ./.cowork-flow/run task validate <dir>                     Validate jsonl files
+  ./.cowork-flow/run task list-context <dir>                 List jsonl entries
+  ./.cowork-flow/run task start <dir>                        Set as current task
+  ./.cowork-flow/run task finish                             Clear current task
+  ./.cowork-flow/run task archive <task-name>                Archive completed task
+  ./.cowork-flow/run task add-subtask <parent> <child>       Link child task to parent
+  ./.cowork-flow/run task remove-subtask <parent> <child>    Unlink child from parent
+  ./.cowork-flow/run task list [--mine] [--status <status>]  List tasks
+  ./.cowork-flow/run task list-archive [YYYY-MM]             List archived tasks
 
 Arguments:
   dev_type: backend | frontend | fullstack | test | docs
@@ -1333,18 +1333,18 @@ List options:
   --status, -s <s>     Filter by status (planning, in_progress, review, completed)
 
 Examples:
-  python3 task.py create "Add login feature" --slug add-login
-  python3 task.py create "Child task" --slug child --parent .cowork-flow/tasks/01-21-parent
-  python3 task.py init-context .cowork-flow/tasks/01-21-add-login backend
-  python3 task.py add-context <dir> implement .cowork-flow/spec/backend/auth.md "Auth guidelines"
-  python3 task.py start .cowork-flow/tasks/01-21-add-login
-  python3 task.py finish
-  python3 task.py archive add-login
-  python3 task.py add-subtask parent-task child-task  # Link existing tasks
-  python3 task.py remove-subtask parent-task child-task
-  python3 task.py list                               # List all active tasks
-  python3 task.py list --mine                        # List my tasks only
-  python3 task.py list --mine --status in_progress   # List my in-progress tasks
+  ./.cowork-flow/run task create "Add login feature" --slug add-login
+  ./.cowork-flow/run task create "Child task" --slug child --parent .cowork-flow/tasks/01-21-parent
+  ./.cowork-flow/run task init-context .cowork-flow/tasks/01-21-add-login backend
+  ./.cowork-flow/run task add-context <dir> implement .cowork-flow/spec/backend/auth.md "Auth guidelines"
+  ./.cowork-flow/run task start .cowork-flow/tasks/01-21-add-login
+  ./.cowork-flow/run task finish
+  ./.cowork-flow/run task archive add-login
+  ./.cowork-flow/run task add-subtask parent-task child-task  # Link existing tasks
+  ./.cowork-flow/run task remove-subtask parent-task child-task
+  ./.cowork-flow/run task list                               # List all active tasks
+  ./.cowork-flow/run task list --mine                        # List my tasks only
+  ./.cowork-flow/run task list --mine --status in_progress   # List my in-progress tasks
 """)