@hunyed15/codecgc 0.1.6 → 0.1.8

package/scripts/codecgc_runtime/routing_template.py

@@ -0,0 +1,169 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import yaml
+
+
+DEFAULT_FRONTEND_PATHS = [
+    "apps/web/**",
+    "src/components/**",
+    "src/pages/**",
+    "src/app/**",
+    "src/styles/**",
+    "web/**",
+    "frontend/**",
+]
+
+DEFAULT_BACKEND_PATHS = [
+    "apps/api/**",
+    "server/**",
+    "src/server/**",
+    "src/services/**",
+    "src/repositories/**",
+    "backend/**",
+]
+
+DEFAULT_SHARED_PATHS = [
+    "packages/shared/**",
+    "src/shared/**",
+    "src/lib/**",
+    "src/types/**",
+]
+
+DEFAULT_ORCHESTRATION_PATHS = [
+    "codecgc/**",
+    ".claude/commands/**",
+    ".claude/settings.json",
+    ".mcp.json",
+    "model-routing.yaml",
+]
+
+DEFAULT_DOCS_PATHS = [
+    "README.md",
+    "INSTALLATION.md",
+    "docs/**",
+    "CHANGELOG.md",
+]
+
+DEFAULT_BACKEND_TEST_PATHS = [
+    "apps/api/*.test.*",
+    "apps/api/*.spec.*",
+    "apps/api/**/*.test.*",
+    "apps/api/**/*.spec.*",
+    "tests/backend/**",
+]
+
+DEFAULT_FRONTEND_TEST_PATHS = [
+    "apps/web/*.test.*",
+    "apps/web/*.spec.*",
+    "apps/web/**/*.test.*",
+    "apps/web/**/*.spec.*",
+    "tests/frontend/**",
+]
+
+DEFAULT_RULES = {
+    "claude_allowed_owners": ["orchestration", "docs"],
+    "backend_executor": "codexmcp",
+    "frontend_executor": "geminimcp",
+    "shared_policy": "split-first",
+}
+
+
+def _render_list_block(name: str, items: list[str]) -> list[str]:
+    lines = [f"{name}:"]
+    for item in items:
+        lines.append(f'  - "{item}"')
+    return lines
+
+
+def _render_nested_list_block(name: str, groups: dict[str, list[str]]) -> list[str]:
+    lines = [f"{name}:"]
+    for group_name, items in groups.items():
+        lines.append(f"  {group_name}:")
+        for item in items:
+            lines.append(f'    - "{item}"')
+    return lines
+
+
+def _render_rules_block() -> list[str]:
+    lines = ["rules:"]
+    for key, value in DEFAULT_RULES.items():
+        if isinstance(value, list):
+            lines.append(f"  {key}:")
+            lines.extend(f'    - "{item}"' for item in value)
+        else:
+            lines.append(f'  {key}: "{value}"')
+    return lines
+
+
+def render_default_routing_yaml() -> str:
+    lines: list[str] = [
+        "version: 2",
+        "",
+        *_render_list_block("orchestration_paths", DEFAULT_ORCHESTRATION_PATHS),
+        "",
+        *_render_list_block("docs_paths", DEFAULT_DOCS_PATHS),
+        "",
+        *_render_list_block("frontend_paths", DEFAULT_FRONTEND_PATHS),
+        "",
+        *_render_list_block("backend_paths", DEFAULT_BACKEND_PATHS),
+        "",
+        *_render_nested_list_block(
+            "test_paths",
+            {
+                "frontend": DEFAULT_FRONTEND_TEST_PATHS,
+                "backend": DEFAULT_BACKEND_TEST_PATHS,
+            },
+        ),
+        "",
+        *_render_list_block("shared_paths", DEFAULT_SHARED_PATHS),
+        "",
+        *_render_rules_block(),
+        "",
+    ]
+    return "\n".join(lines)
+
+
+def _normalize_line_endings(text: str) -> str:
+    return text.replace("\r\n", "\n").replace("\r", "\n")
+
+
+def _extract_list_block(lines: list[str], block_name: str) -> list[str]:
+    items: list[str] = []
+    inside = False
+    for line in lines:
+        stripped = line.strip()
+        if not inside:
+            if stripped == f"{block_name}:":
+                inside = True
+            continue
+
+        if line and not line.startswith(" "):
+            break
+        if stripped.startswith("- "):
+            value = stripped[2:].strip()
+            if len(value) >= 2 and value[0] == value[-1] and value[0] in {'"', "'"}:
+                value = value[1:-1]
+            if value:
+                items.append(value)
+    return items
+
+
+def merge_routing_template(existing_text: str) -> str:
+    if existing_text.strip():
+        try:
+            data = yaml.safe_load(existing_text)
+        except yaml.YAMLError:
+            data = None
+        if isinstance(data, dict) and int(data.get("version", 0) or 0) == 2:
+            return _normalize_line_endings(existing_text).rstrip() + "\n"
+    return render_default_routing_yaml()
+
+
+def sync_workspace_routing_file(target_path: Path) -> Path:
+    existing_text = target_path.read_text(encoding="utf-8") if target_path.exists() else ""
+    merged_text = merge_routing_template(existing_text)
+    target_path.parent.mkdir(parents=True, exist_ok=True)
+    target_path.write_text(merged_text, encoding="utf-8")
+    return target_path

package/scripts/codecgc_runtime/workflow_runtime.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+from typing import Any
+
+from .paths import PACKAGE_ROOT
+from .paths import PROJECT_ROOT
+
+
+WORKSPACE = PACKAGE_ROOT
+PROJECT_WORKSPACE = PROJECT_ROOT
+SCRIPTS_DIR = WORKSPACE / "scripts"
+
+
+def build_script_command(script_name: str, *args: str) -> list[str]:
+    return [sys.executable, str(SCRIPTS_DIR / script_name), *args]
+
+
+def parse_json_text(text: str) -> dict[str, Any]:
+    stripped = text.strip()
+    if not stripped:
+        raise ValueError("Command produced no JSON output.")
+    return json.loads(stripped)
+
+
+def run_json_script(script_name: str, *args: str) -> dict[str, Any]:
+    command = build_script_command(script_name, *args)
+
+    env = os.environ.copy()
+    env["CODECGC_WORKSPACE_ROOT"] = str(PROJECT_WORKSPACE)
+
+    completed = subprocess.run(
+        command,
+        cwd=PROJECT_WORKSPACE,
+        stdin=subprocess.DEVNULL,
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+        env=env,
+    )
+
+    stdout = completed.stdout.strip()
+    stderr = completed.stderr.strip()
+
+    if completed.returncode == 0:
+        if not stdout:
+            return {"success": True}
+        return parse_json_text(stdout)
+
+    for candidate in (stdout, stderr):
+        if not candidate:
+            continue
+        try:
+            parsed = parse_json_text(candidate)
+        except Exception:
+            continue
+        if isinstance(parsed, dict):
+            parsed.setdefault("success", False)
+            parsed.setdefault("returncode", completed.returncode)
+            return parsed
+
+    return {
+        "success": False,
+        "returncode": completed.returncode,
+        "stdout": stdout,
+        "stderr": stderr,
+        "error": f"{script_name} failed with exit code {completed.returncode}.",
+    }

package/scripts/codecgc_runtime_paths.py

@@ -1,22 +1,3 @@
-from __future__ import annotations
-
-import os
-from pathlib import Path
-
-
-PACKAGE_ROOT = Path(__file__).resolve().parents[1]
-
-
-def resolve_workspace_root(override_workspace: str = "") -> Path:
-    explicit = str(override_workspace or "").strip()
-    if explicit:
-        return Path(explicit).expanduser().resolve()
-
-    configured = os.environ.get("CODECGC_WORKSPACE_ROOT", "").strip()
-    if configured:
-        return Path(configured).expanduser().resolve()
-
-    return Path.cwd().resolve()
-
-
-PROJECT_ROOT = resolve_workspace_root()
+from codecgc_runtime.paths import PACKAGE_ROOT
+from codecgc_runtime.paths import PROJECT_ROOT
+from codecgc_runtime.paths import resolve_workspace_root

package/scripts/codecgc_step_control.py

@@ -34,9 +34,8 @@ def is_executable_codecgc_block(codecgc: Any) -> bool:
     if any(is_placeholder_path(path) for path in target_paths):
         return False
 
-    task_id = str(codecgc.get("task_id", "")).strip()
     task_summary = str(codecgc.get("task_summary", "")).strip()
-    return bool(task_id and task_summary)
+    return bool(task_summary)
 
 
 def is_test_codecgc_block(codecgc: Any) -> bool:
@@ -87,6 +86,7 @@ def select_next_executable_step(checklist_path: Path) -> dict[str, Any]:
         "task_id": str(codecgc.get("task_id", "")),
         "action": str(step.get("action", "")),
         "kind": str(codecgc.get("kind", "")),
+        "step_type": str(codecgc.get("step_type", "")),
         "target_paths": codecgc.get("target_paths", []),
         "task_summary": str(codecgc.get("task_summary", "")),
         "artifact_type": resolve_artifact_type(data),
@@ -107,6 +107,7 @@ def get_step_metadata(checklist_path: Path, step_number: int) -> dict[str, Any]:
         "task_id": str(codecgc.get("task_id", "")),
         "action": str(step.get("action", "")) if isinstance(step, dict) else "",
         "kind": str(codecgc.get("kind", "")),
+        "step_type": str(codecgc.get("step_type", "")),
         "target_paths": codecgc.get("target_paths", []),
         "task_summary": str(codecgc.get("task_summary", "")),
         "artifact_type": resolve_artifact_type(data),

package/scripts/codecgc_workflow_runtime.py

@@ -1,71 +1,3 @@
-import json
-import os
-import subprocess
-import sys
-from pathlib import Path
-from typing import Any
-
-from codecgc_runtime_paths import PACKAGE_ROOT
-from codecgc_runtime_paths import PROJECT_ROOT
-
-WORKSPACE = PACKAGE_ROOT
-PROJECT_WORKSPACE = PROJECT_ROOT
-SCRIPTS_DIR = WORKSPACE / "scripts"
-
-
-def build_script_command(script_name: str, *args: str) -> list[str]:
-    return [sys.executable, str(SCRIPTS_DIR / script_name), *args]
-
-
-def parse_json_text(text: str) -> dict[str, Any]:
-    stripped = text.strip()
-    if not stripped:
-        raise ValueError("Command produced no JSON output.")
-    return json.loads(stripped)
-
-
-def run_json_script(script_name: str, *args: str) -> dict[str, Any]:
-    command = build_script_command(script_name, *args)
-
-    # 设置环境变量,确保子进程使用正确的工作目录
-    env = os.environ.copy()
-    env["CODECGC_WORKSPACE_ROOT"] = str(PROJECT_WORKSPACE)
-
-    completed = subprocess.run(
-        command,
-        cwd=PROJECT_WORKSPACE,
-        stdin=subprocess.DEVNULL,
-        capture_output=True,
-        text=True,
-        encoding="utf-8",
-        errors="replace",
-        env=env,  # 传递环境变量
-    )
-
-    stdout = completed.stdout.strip()
-    stderr = completed.stderr.strip()
-
-    if completed.returncode == 0:
-        if not stdout:
-            return {"success": True}
-        return parse_json_text(stdout)
-
-    for candidate in (stdout, stderr):
-        if not candidate:
-            continue
-        try:
-            parsed = parse_json_text(candidate)
-        except Exception:
-            continue
-        if isinstance(parsed, dict):
-            parsed.setdefault("success", False)
-            parsed.setdefault("returncode", completed.returncode)
-            return parsed
-
-    return {
-        "success": False,
-        "returncode": completed.returncode,
-        "stdout": stdout,
-        "stderr": stderr,
-        "error": f"{script_name} failed with exit code {completed.returncode}.",
-    }
+from codecgc_runtime.workflow_runtime import build_script_command
+from codecgc_runtime.workflow_runtime import parse_json_text
+from codecgc_runtime.workflow_runtime import run_json_script

package/scripts/entry_codecgc_workflow.py

@@ -3033,6 +3033,10 @@ def run_existing_mode(args: argparse.Namespace, explain_only: bool) -> dict[str,
         "dispatched": False,
         "dispatch_result": None,
     }
+    if matches_command(recommended_command, "cgc-plan") and isinstance(route.get("replan_payload"), dict):
+        merged_replan_payload = dict(replan_payload)
+        merged_replan_payload.update(route.get("replan_payload", {}))
+        result["replan_payload"] = merged_replan_payload
     if explain_only or not effective_auto_dispatch:
         result["next"] = build_user_facing_next(result)
         result["human_summary"] = build_existing_mode_human_summary(result)